Discussion :

[calogerogigante]

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 :

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
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 :

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

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).

[calogerogigante]

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

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

[sinok]

Il y a pire comme méthode, déja tu n'utilise pas la dangereuse et deprecated méthode stop() de ton thread

[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 , je suis preneur, chers amis...

[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

[ricardvince]

moi jai deja utiliser la methode :

Code :

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

1
2
 
tonThreads.resulme();

cette methose reprends ton threads ou il cetait arreter

[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

[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 !!

[ricardvince]

desole javais oublie quelle etaient depreciated...

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

[calogerogigante]

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 :

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
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.

[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

[calogerogigante]

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

Grazie mille !

[adiGuba]

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 :

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

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++

[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...

[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.

[adiGuba]

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...

[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à !!

[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.

[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...

[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.