Discussion :

[Samshay]

Bonjour,
Je vous explique ma petite histoire. J'ai un thread A.
Le thread A va crée des thread,on va prendre en particulier un thread B. Ce thread B va faire une pause : ThreadB.sleep(5000).
Le problème avec cette méthode, c'est que le thread B fait bien sa pause mais elle met aussi le thread A en attente.
Merci de m'éclairer.

[kaizokuni]

Bonsoir,

pourrais tu donner ton code s'il te plait?

merci

[Samshay]

ba y'a rien de compliquer mais bon si ça peut vous aider :



La classe GestionSalon qui creer les thread.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class GestionSalon implements Runnable
{
        private int tempsTraitement;
        private int tempsClient;
        private int nombreClient;
        private IhmSalon monIhm;
        private Semaphore siege;
        private ArrayList<Client> listeClient;
        
        GestionSalon(IhmSalon monIhm)
        {
            siege=new Semaphore(3);
            this.monIhm=monIhm; 
            tempsTraitement=monIhm.getTempsTraitement();
            tempsClient=monIhm.getTempsClient();
            listeClient=new ArrayList<Client>();
            nombreClient=0;
        }
        public void coiffer(int numeroClientcourant)
        {
        try {
            siege.acquire();            
            listeClient.get(numeroClientcourant).setSiegePris(monIhm.prendreSiege());
            listeClient.get(numeroClientcourant).pause(10000);
            monIhm.libererSiege( listeClient.get(numeroClientcourant).getSiegePris());
            siege.release();
        } catch (InterruptedException ex) {
            Logger.getLogger(GestionSalon.class.getName()).log(Level.SEVERE, null, ex);
        }
        }
        private void pause(int temps)
        {
            try {
                Thread.currentThread().sleep(temps);
            } catch (InterruptedException ex) {
                Logger.getLogger(GestionSalon.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
// c'est ici que les thread sont cree
    public void run() {
        Client tamponClient;
        while(true)
        {
            tamponClient=new Client(this);
            tamponClient.setNumeroClient(nombreClient);            
            listeClient.add(nombreClient,tamponClient);
            nombreClient++;
            tamponClient.run();  
            tamponClient=null;
            pause(3*1000);          
        }
    }

        

}

Les thread crees sont de types Client:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
public class Client implements Runnable
{
    private GestionSalon monGestionSalon;
    private int siegePris;
    private int numeroClient;
 
    Client(GestionSalon monGestionSalon)
    {
        this.monGestionSalon=monGestionSalon;
    }
    public void run() {
            monGestionSalon.coiffer(numeroClient);
            Thread.interrupted();
 
    }
    public void pause(int temps)
    {
        try {
            Thread.currentThread().sleep(temps);
        } catch (InterruptedException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    public int getSiegePris() {
        return siegePris;
    }
 
    public void setSiegePris(int siegePris) {
        this.siegePris = siegePris;
    }
 
    public int getNumeroClient() {
        return numeroClient;
    }
 
    public void setNumeroClient(int numeroClient) {
        this.numeroClient = numeroClient;
    }

}

[gulain]

Bonjour,
un thread en Java doit étendre java.lang.Thread (et non pas implémenter l'interface Runnable) et on le lance en appelant la méthode start() (et pas run()).

Voir par exemple : http://viennet.developpez.com/cours/java/thread/#LII-C

[Samshay]

J'ai résolu mon problème au lieu d'implémenter l'interface runnable pour la classe client je l'ai fais hérité de classe Thread.
Mais j'ai lu le tuto que tu m'as passé et il est dit :

L'autre moyen de créer un thread est de déclarer une classe qui implémente l'interface Runnable. Cette interface déclare seulement une méthode : run().

Donc c'est quoi la différence alors.

[adiGuba]

Salut,

un thread en Java doit étendre java.lang.Thread (et non pas implémenter l'interface Runnable)

Il est tout à fait possible d'implémenter Runnable et de passer l'instance en paramètre du thread qu'on crée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new Thread(monRunnable);

Donc c'est quoi la différence alors.

Runnable définit seulement une interface avec une seule méthode : run(). C'est cette méthode qui sera exécuté par le thread.

Mais si tu l'appelles directement tu ne crées pas de thread : tu appelles simplement une méthode quelconque !

Pour créer un thread il faut appeler la méthode start() de ton objet Thread, et c'est elle qui appellera la méthode run() dans un nouveau thread...

a++

[Samshay]

Merci en faite je suis juste un boulet, j'avais complètement zappé. Merci quand meme.