[JPanel] un thread pas très catholique...

Version imprimable

Bonjour les éclairés du java !!

Voilà, je me lance simultanément dans le dégrossisage des threads et du double buffering.

Ma question est la suivante, concernant le thread :
Dans mon JPanel, j'ai une classe qui étends Thread, la voici :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class ThreadDeDessin extends Thread { private boolean tuer = false; public void run() { while( true ) { try { preparerProchainPoint(); repaint(); sleep(100); } catch( InterruptedException e ) { } if ( tuer ) return; } } public void arreter() { tuer = true; } }
Et j'ai trois méthodes externes pour lancer, tuer et reprendre un thread.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public void demarrerThread() { thr.start(); } public void arreterThread() { thr.arreter(); } public void reprendreThread() { thr = new ThreadDeDessin(); thr.start(); }
Je ne suis pas certain que la méthode du relancement soit bonne (càd re-créer une nouvelle instance de ma classe ThreadDeDessin à chaque redémarrage de l'action de dessiner aléatoirement).
Pourtant, mon petit programme test fonctionne parfaitement.

Si vous pouviez me dire ce que vous en pensez, ça pourrait m'aider...
(Voir les fichiers sources complets attachés à ce post).

11/05/2006, 13h17
calogerogigante

Personne n'est chaud pour un petit commentaire sur la façon dont j'ai géré mes threads ?:pleure:

Je voudrais juste savoir s'il est concevable de gérer un thread comme je l'ai fait ?

:cry:
11/05/2006, 13h29
sinok

Il y a pire comme méthode, déja tu n'utilise pas la dangereuse et deprecated méthode stop() de ton thread
11/05/2006, 14h42
calogerogigante

Ma crainte est de me retrouver avec des tas de petites instances de ma classe ThreadDeDessin (cf à chaque redémarrage du traçage aléatoire), et que le Garbage Collector ne se mette à freiner l'application quand il nettoiera les instances perdues, si je devais utiliser un jour cette façon de faire dans une application plus importante et plus gourmande en nombre de thread utilisé.

Si quelqu'un a une autre méthode que celle que j'ai appliqué tout seul comme un grand :mouarf: , je suis preneur, chers amis...
11/05/2006, 15h17
sinok

Tout dépend de tes besoins
Si un seul thread te suffit => Singleton (regarde les sources de dvp pour le singleton en environnement threadé)
Si tu nécessite plus de threads mais que tu veux en limiter le nombre un petit pool de threads pourraient faire l'affaire
11/05/2006, 18h16
ricardvince
moi jai deja utiliser la methode :
Code:

1 2 tonThreads.resulme();
cette methose reprends ton threads ou il cetait arreter
11/05/2006, 18h22
sinok

Malheureusement pour toi jeune homme tu vas devoir arrêter de l'utiliser car elle est deprecated et considérée dangereuse....
Et puis dans le cas présent je ne vois pas trop bien le rapport avec le sujet
11/05/2006, 18h34
calogerogigante

Benh, en fait, si, ça colle avec mon sujet, car mon soucis est bien de faire le plus proprement possible le codage d'un thread qu'on puisse lancer, arrêter, et surtout, redémarrer. Toutes ces méthodes deprecated sont frustrantes...

J'ai été voir, ami Sinok, le tutoriel de Developpez sur le thread en singleton. Mais je l'ai trouvé assez compliqué.

J'avais essayé d'abord comme ça (en singleton), mais mon problème, je ne sais pas pourquoi, mon compilateur refusait de surcharger la méthode stop().
Pourquoi ? Aucune idée...

Si quelqu'un a l'habilité de transformer mon petit exemple avec un beau Thread en singleton, et codé dans les règles de l'Art, je ne demande qu'à apprendre !!
:lol: :lol:
11/05/2006, 18h39
ricardvince

desole javais oublie quelle etaient depreciated...

mais ca devient vraiment soulant ces "depreciated"...:cry:

J'ai trouvé une variante plus propre pour stopper et relancer mon thread, sans devoir à chaque fois en créer une nouvelle instance :

Dans la classe PanneauDeDessin :

Code:

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
public void demarrerThread()
  {
  thr.start();
  }
 
public void arreterThread()
  {
  thr.arreter();
  }
 
public void reprendreThread()
  {
  thr.tuer = false;
  }
 
public class ThreadDeDessin extends Thread
  {
  public boolean tuer = false;
  public void run()
    {
      while( true )
        {
        if ( !tuer )
          {
          try {
              preparerProchainPoint();
              repaint();
              sleep(100);
              }
          catch( InterruptedException e ) { }
          }
        }
    }
  public void arreter()
    {
    tuer = true;
    }
  }

Ca tourne bien... Si personne n'a d'autres commentaires, je mets ce post en résolu, car c'est OK pour moi.
:mrgreen:

12/05/2006, 12h19
sinok

Perso j'éviterais de déclarer ton tuer public et je prévoierais une deuxiéme variable permettant de killer définitivement ton thread (il y a surement un moment ou il ne servira plus
12/05/2006, 12h32
calogerogigante

En effet, Sinok, ce sont deux excellentes suggestions auxquelles je n'ai pas pensé !

Grazie mille !
:P

Salut,

Tu peux tout simplement utiliser la méthode interrupt() à la place de ta méthode arreter(), qui gère en plus la synchronisation et qui permet de stopper certaine méthodes bloquantes (sleep(), certain read()/write(), etc.) en provoquant une InterruptedException :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class ThreadDeDessin extends Thread { public void run() { while( true ) { if ( !isInterrupted() ) { try { preparerProchainPoint(); repaint(); sleep(100); } catch( InterruptedException e ) { } } } } }
Et tu n'as plus qu'à utiliser interrupt() pour stopper ton Thread...

a++

12/05/2006, 15h02
calogerogigante

OK, merci pour l'info...

http://java.sun.com/j2se/1.4.2/docs/...tml#interrupt()

Je vais essayer ta proposition ce soir chez moi.

Je fais un feedback si j'ai des problèmes, mais encore merci...
12/05/2006, 16h05
xavlours

Bon, j'arrive un peu après la bataille, mais si tu veux pouvoir :
- arrêter ton thread
- le redémarrer
Pour moi, c'est wait/notify. Et pour le tuer définitivement, interrupt.
12/05/2006, 16h08
adiGuba

Citation:

Envoyé par xavlours

Bon, j'arrive un peu après la bataille, mais si tu veux pouvoir :
- arrêter ton thread
- le redémarrer
Pour moi, c'est wait/notify. Et pour le tuer définitivement, interrupt.

Oups... oui c'est vrai je n'avais pas remarqué qu'il y avait deux bloc while...
12/05/2006, 17h06
calogerogigante

Bon, je ne sais plus quelle méthode je vais utiliser, moi ???

Allez ! Je vais encore faire plein de chipotages ce soir, pour tester toutes vos propositions, là !!

:aie:
12/05/2006, 17h22
xavlours

Dans le code que tu as posté, calogerogigante, il y a un gros problème :
si tuer est faux, ton thread est en while(true){} et consomme 100% de cpu.
12/05/2006, 17h24
calogerogigante

Oui, je sais !!

Et je suis prêt à étudier vos propositions de code (ce soir chez moi), pour éviter cet état de fait !!

(Je suis encore en pleine phase (éternelle) d'apprentissage de java !!)
Be mercyfull...
:P :P :mouarf:
12/05/2006, 17h37
xavlours

Eh bien le meilleur code est celui fourni en exemple ici, vers la fin de la page. Ils prennent même en compte la possibilité qu'un thread appelle la pause et l'autre le tue en même temps.

Mon premier exemple était faux, désolé...

Voici quelques choses de plus propre pour mettre en pause ou arrêter un thread :
Code:

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 class ThreadDeDessin extends Thread { private boolean isPaused = false; public void run() { // Tant que le thread n'est pas interrompue try { // On vérifie l'état de la pause (méthode bloquante) : checkPause(); // On effectue les traitement preparerProchainPoint(); repaint(); sleep(1000); } catch( InterruptedException e ) { // En cas d'InterruptedException on sort de suite : } } protected synchronized void checkPause() throws InterruptedException { if (isInterrupted()) { // Si le thread est déjà interrompu, on provoque une exception : throw new InterruptedException(); } if (this.isPaused) { // Si on est en pause, on met le thread en attente : // Le wait() libère le verrou du synchronized : this.wait(); } } public synchronized void setPaused(boolean newValue) { isPaused = newValue; if (!this.isPaused) { // Lorsqu'on enlève la pause, on envoit une notification au thread : this.notify(); } } }
interrupt() permet de stopper le thread.
setPaused(true) permet de mettre le thread en pause.
setPaused(false) permet de sortir le thread de la pause.

Explication :

Le try/catch global permet d'intercepter les InterruptedException dans les cas où l'appel à interrupt() a lieu pendant que le thread est en attente dans wait() ou sleep(). Dans ces cas là le thread est arrêté de suite.

La méthode checkPause() vérifie si le thread doit se mettre en pause et l'endort avec wait() le cas échéant. On vérifie d'abord l'état de isInterrupted() afin de terminer le thread si besoin...

La méthode setPaused() permet de modifier l'état de pause du thread. Dans le cas où on sort d'une pause on envoi un notify() afin de réveiller le thread s'il était déjà rentré en sommeil dans wait()...

La principale différence entre ces méthodes et les méthodes original stop(), suspend() et resume(), c'est que si l'appel survient pendant ton traitement (preparerProchainPoint() ou repaint()), elles n'auront aucune influence sur leurs déroulements (mis à part si tu utilises à l'intérieur d'autres méthodes interruptible...), et la pause/fin du thread n'aura réellement lieux qu'à la fin du traitement.

Ainsi tu n'a pas un comportment hyper-réactif (la pause n'aura pas forcément lieu instantannément), mais tu évites de te retrouver avec des objets ou des valeurs dans des états incorrects, ce qui pourrait provoquer des erreurs autres part dans ton application...

a++

13/05/2006, 14h25
calogerogigante

Merci pour toute cette explication très claire, Adiguba.

J'ai donc analysé et essayé ta classe telle quelle, mais j'ai maintenant un problème très bizarre : les droites aléatoires ne démarrent plus...

Seule la 1ère droite est tracée, et puis plus rien : figé !!
On dirait que la méthode run() n'est pas lancée quand on démarre le thread avec start()...

Bizarre ? Bizarre ?

Est-ce que le petit programme fonctionne bien chez toi (avec ta version de la classe ThreadDeDessin) ?

Citation:

Envoyé par calogerogigante

Seule la 1ère droite est tracée, et puis plus rien : figé !!
On dirait que la méthode run() n'est pas lancée quand on démarre le thread avec start()...

Bizarre ? Bizarre ?

Non... en fait j'ai encore faire une connerie :aie:
J'ai oublié la boucle infini dans la méthode run() (je n'avais pas vraiment testé avec ton code et j'ai enlevé trop de chose...) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 public void run() {
            // Tant que le thread n'est pas interrompue
            try {
                while(true) {
                    // On vérifie l'état de la pause (méthode bloquante) :
                    checkPause();
                    
                    // On effectue les traitement
                    preparerProchainPoint();
                    repaint();
                    sleep(1000);
                }
            } catch( InterruptedException e ) {
                // En cas d'InterruptedException on sort de suite :
            }
        }

Sinon, étant donné que tu modifies ton composant graphique dans la méthode preparerProchainPoint(), il vaudrait mieux effectuer ce traitement dans l'EDT :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
        public void run() {
            Runnable task = new Runnable() {
                public void run() {
                    preparerProchainPoint();
                    repaint();
                }
            };
            // Tant que le thread n'est pas interrompue
            try {
                while(true) {
                    // On vérifie l'état de la pause (méthode bloquante) :
                    checkPause();
                    
                    // On effectue les traitement
                    SwingUtilities.invokeLater(task);
                    sleep(1000);
                }
            } catch( InterruptedException e ) {
                // En cas d'InterruptedException on sort de suite :
            }
        }

a++

Bon, Adiguba, c'est OK. Tout marche très bien maintenant. Grâce à cette façon de faire avec les threads, j'ai pu me passer de devoir gérer l'aspect enabled ou non des 3 boutons. Car la méthode fonctionne dans tous les cas (exemple : pas d'erreur si je fais l'action de mettre en pause le thread quand celui-ci est déjà en pause.)

J'ai encore une petite question, mais avant, je poste le code de mon traçeur de droites aléatoires, au thread amélioré :

Code:

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
57
58
59
60
61
62
63
import java.awt.*;
import java.awt.event.*;
 
import javax.swing.*;
 
public class FenetrePrincipale extends JFrame
                               implements ActionListener
{
public PanneauDeDessin pan = new PanneauDeDessin();
 
public JButton continu = new JButton("Continuer à tracer");
public JButton stopper = new JButton("Arrêter");
public JButton effacer = new JButton("Effacer");
 
public FenetrePrincipale()
{
  super("Droites aléatoires");
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  getContentPane().add(pan, BorderLayout.CENTER);
  pan.demarrerThread();
  FlowLayout fl = new FlowLayout(FlowLayout.CENTER);
  JPanel sous_pan = new JPanel(fl);
  sous_pan.add(continu); continu.addActionListener(this);
  sous_pan.add(stopper); stopper.addActionListener(this);
  sous_pan.add(effacer); effacer.addActionListener(this);
  getContentPane().add(sous_pan, BorderLayout.SOUTH);
 
  pack();
  setVisible(true);
}
 
public void actionPerformed(ActionEvent ev)
{
if((JButton)(ev.getSource()) == continu)
  {
  pan.reprendreThread();
  System.out.println("Continuer");
  }
if((JButton)(ev.getSource()) == stopper)
  {  
  pan.arreterThread();
  System.out.println("Stopper");
  }
if((JButton)(ev.getSource()) == effacer)
  {
  pan.effacerEcran();
  System.out.println("Effacer");
  }
}
 
public static void main(String[] args)
  {
  try
    {
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
  catch (Exception e)
    {
    System.out.println(e);
    }
  new FenetrePrincipale();
  }
}

Et la deuxième classe :

Code:

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import javax.swing.*;
import java.awt.*;
import java.util.*;
 
public class PanneauDeDessin extends JPanel
{
public ThreadDeDessin thr = new ThreadDeDessin();
 
int large = 500;
int longu = 300;
 
int X1=large/2,
    Y1=longu/2,
    X2=large/2,
    Y2=longu/2;
 
Graphics buffer;
Image    image;
 
public PanneauDeDessin()
  {
  setPreferredSize(new Dimension(large, longu));
  }
 
public void paintComponent(Graphics g)
  {
  if (buffer==null)
    {
    image  = createImage(large, longu);
    buffer = image.getGraphics();
    buffer.setColor(Color.WHITE);
    buffer.fillRect(0, 0, large, longu);
    }
 
  buffer.setColor( choixDUneCouleur() );
  buffer.drawLine(X1,Y1,X2,Y2);
 
  g.drawImage(image, 0, 0, this);
  }
 
public void effacerEcran()
{
  buffer.setColor(Color.WHITE);
  buffer.fillRect(0,0,large,longu);
  buffer.setColor(Color.BLACK);
  repaint();
}
public Color choixDUneCouleur()
{
Random rand = new Random();
int R = rand.nextInt(255);
int G = rand.nextInt(255);
int B = rand.nextInt(255);
return new Color(R,G,B);
}
 
public void preparerProchainPoint()
  {
  Random rand = new Random();
  X1 = X2;
  Y1 = Y2;
  X2 = rand.nextInt(large);
  Y2 = rand.nextInt(longu);
  }
 
public void demarrerThread()
  {
  thr.start();
  }
 
public void arreterThread()
  {
  thr.setPaused(true); 
  }
 
public void reprendreThread()
  {
  thr.setPaused(false);
  }
 
class ThreadDeDessin extends Thread
{
    private boolean isPaused = false;
 
    public void run()
    {
        Runnable task = new Runnable() {
                                       public void run()
                                          {
                                          preparerProchainPoint();
                                          repaint();
                                          }
                                       };
        // Tant que le thread n'est pas interrompu
        try {
            while(true)
                {
                // On vérifie l'état de la pause (méthode bloquante) :
                checkPause();
 
                // On effectue les traitement
                SwingUtilities.invokeLater(task);
                sleep(100);
                }
            }
        catch( InterruptedException e )
            {
            // En cas d'InterruptedException on sort de suite :
            }
    }
 
    protected synchronized void checkPause() throws InterruptedException
    {
        if (isInterrupted())
        {
                // Si le thread est déjà interrompu, on provoque une exception :
                throw new InterruptedException();
        }
        if (this.isPaused)
        {
            // Si on est en pause, on met le thread en attente :
            // Le wait() libère le verrou du synchronized :
            this.wait();
        }
    }
 
    public synchronized void setPaused(boolean newValue)
    {
        isPaused = newValue;
        if (!this.isPaused)
        {
            // Lorsqu'on enlève la pause, on envoit une notification au thread :
            this.notify();
        }
    }
}
}

Ma question : maintenant, si je désirais tuer totalement le thread (pas dans cet exemple mais éventuellement dans un autre programme (càd pour que l'objet thread soit complètement détruit de la mémoire), comment je dois faire ?

Car la mise en pause, ici, dans la dernière version de ce programme, ne le tue en aucun cas ???

Je dois faire appel à interrupt() , c'est ça ?

21/05/2006, 22h28
adiGuba
Citation:

Envoyé par calogerogigante

Ma question : maintenant, si je désirais tuer totalement le thread (pas dans cet exemple mais éventuellement dans un autre programme (càd pour que l'objet thread soit complètement détruit de la mémoire), comment je dois faire ?

Car la mise en pause, ici, dans la dernière version de ce programme, ne le tue en aucun cas ???

Je dois faire appel à interrupt() , c'est ça ?

Oui...

En fait lorsque tu appelles la méthode interrupt() depuis un autre thread tu as trois grand cas :
- Le thread est dans une méthode de sommeil (wait(), sleep(), join()), et dans ce cas l'attente est interrompu par une InterruptedException.
- Le thread est dans une méthode bloquante d'un InterruptibleChannel, et dans ce cas tu obtiens une ClosedByInterruptException...
- Sinon le thread continue son déroulement normal...
Mais dans tous les cas le status du thread passe à interrupted...

Dans ton cas, seul le premier et le dernier cas te concerne (puisque tu n'utilises pas de Channel). Lorsque tu appelles la méthode interrupt() :
- Si ton thread est dans une des méthodes d'attentes (sleep() ou wait()), alors l'InterruptedException te sort de la boucle infini en rentrant dans le catch. Tu arrive donc à la fin de la méthode run() ce qui met fin à ton thread.
- Si tu n'est pas dans une des méthodes d'attentes, ton thread continuera normalement jusqu'à ce qu'il arrive dans la méthode checkPause() qui vérifie le status 'interuptible' de ton thread (qui sera obligatoirement renseigné lors de l'appel de interrupted()):
Code:

1 2 3 4 5 if (isInterrupted()) { // Si le thread est déjà interrompu, on provoque une exception : throw new InterruptedException(); }
Donc si la méthode interrupted() a été appellé tu renvois un InterruptedException qui provoquera la fin du thread...

Donc dans le pire des cas tu effectueras une boucle de trop dans ton thread, mais il s'arrêtera correctement...

Maintenant si ta boucle de traitement était beaucoup plus longue, il serait mieux de vérifier plusieurs fois l'état interrupted...

Enfin concernant la mémoire, il faut bien sûr que tu mettes ton attribut thr à null une fois que tu l'as arrêter, pour que le GC puissent le 'nettoyer'...

Sinon, juste un détail sur ce code :

Code:

if((JButton)(ev.getSource()) == continu)

Comme tu compares des références, tu n'as pas besoin de faire un cast, ceci marche parfaitement :

Code:

if(ev.getSource() == continu)

Et en plus tu n'as pas de risque de ClassCastException ;)

a++
21/05/2006, 23h01
calogerogigante

Merci pour ces précisions finales, adiguba.

Pour être certain d'avoir compris tout ton développement théorique, je suis maintenant en train de programmer un petit essai avec une interface swing symbolisant le contrôle de 4 voitures. Les voitures peuvent rouler (et donc consomment le nombre de litres d'essence qu'elles ont : c'est un champs integer private), peuvent être mise en pause (arrêt de la consommation), et peuvent avoir un accident (thread tué).

Tu verras que ma classe voiture étends Thread.

J'aurais bientôt fini cet exemple perso (pour améliorer mon aisance dans les threads) dans 2 ou 3 jours... Dès qu'il sera fin prêt, je le mettrais ici pour avoir vos avis et en faire profiter tout le monde : et surtout voir si j'ai bien compris enfin toute cette partie importante de JAVA.
:lol:

P.S. Pour le cast en (JButton), j'ai fait ça car je me souviens avoir eu des problèmes de compilation sans ce cast (je sais plus exactement lesquels), et dès lors, j'ai attrapé le réflexe. Je referais des tests pour voir.