Discussion :

[Pill_S]

bonjour à tous,

je planche sur les threads ces temps-ci, et j'aurais une petite question:

j'ai une classe qui implément Runnable:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class Chrono implements Runnable{
  private boolean isInterrupted
 
  public void run(){
    while(! isInterrupted){
      //traitement
    }
  }
 
  public void interrupt(){
    isInterrupted=true;
  }
}

Je lance le thread en faisan

Code :

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

1
2
3
 
Thread t1 = new Thread(chrono); 
t1.start();

et je le tue en faisant

Code :

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

1
2
 
  chrono.interrupt();

mais ensuite je voudrais le relancer. Est-ce que je suis obligé de recréer un nouveau thread avec la même référence ? Parce si j'applique à nouveau la méthode t1.start(); , il me viens une erreur IllegalThreadStateException ou qq chose du genre...

[Alwin]

a partir du moment ou tu sort de la méthode run(), ton thread est mort !
oui, tu doit recréer ton thread !

[Pill_S]

tip-top, merci Alwin

je faisais déjà comme ça mais ça me paraissait bizarre...

@+

[Alwin]

tu peu aussi mettre ton Thread en suspend mais sans utiliser les méthodes standard ( elle sont dépréciées ) mais de la manière suivante :

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
 
public class Chrono implements Runnable{ 
 
  public void run(){ 
    while(! isInterrupted()){ 
      //traitement 
    } 
  } 
 
  public void pause() {
    synchronized(this) {
      this.wait();
    }
  }  
 
  public void release() {
    synchronized(this) {
      this.notify();
    }
  }  
 
}

[Pill_S]

Code :

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

1
2
3
4
5
6
 
  public void release() { 
    synchronized(this) { 
      this.notify(); 
    } 
  }

:

je comprend pas trop le mot réservé synchronized et la syntaxe que tu utilise !

bon pour l'instant je crois que je v continuer sur l'autre voie, qui n'est pas très jolie mais qui fonctionne

[Alwin]

c'est très simple.
le mot clé synchronized permet de s'assurer qu'à un instant T, un et un seul thread n'utilise cette ressource. C'est un verrou si tu préfère.

Quand tu commence a faire du MultiThreading, il te faut faire attention à ce genre de chose.

Imagine un tableau ou plusieurs Thread irais lire et écrire en même temps. Il te faut t'assurer que les Threads ne se mettre pas en concurence lors de l'accès à ce tableau.

Le mot clé synchronized peut etre utilisé sur une ressource ( instance non null ) ou sur une méthode ( le cas des HashTable dont les méthodes sont synchronisées ).

Ici, pour mettre mon Thread en pause, il faut que personne ne se serve du Thread lui même ! Etant donné que this ne peu en aucun cas être null, pas de souci.

Pour locker une ressource, il te suffis de mettre le code dans un block de synchronisation :

Code :

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

1
2
3
4
 
   synchronized(_tableau) {
    // ici, tu peu manipuler _tableau sans qu'aucun autre Thread le manipule en concurence.
   }

[Pill_S]

Extra !

Merci de ces explications. Je vais essayer cela, je pense que cela me sera bien utile

[fxjtarga]

tu peu aussi mettre ton Thread en suspend mais sans utiliser les méthodes standard ( elle sont dépréciées ) mais de la manière suivante :

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
 
public class Chrono implements Runnable{ 
 
  public void run(){ 
    while(! isInterrupted()){ 
      //traitement 
    } 
  } 
 
  public void pause() {
    synchronized(this) {
      this.wait();
    }
  }  
 
  public void release() {
    synchronized(this) {
      this.notify();
    }
  }  
 
}

attention c egenre de code est dangereu, je m'explique si ailleur dan sle code il y a un notifyAll tu risque de réveiler ton Thread le mieu a faire est une boucle du genre (dans ton run par exemple)

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
 public class Chrono implements Runnable{ 
 
boolean dodo = false;  
 
  public void run(){ 
    while(dodo){ 
      this.wait(); 
    } 
// traitement
  } 
 
  public void pause() {
    synchronized(this) {
      dodo = true;
notifyall();
    }
  }  
 
  public void release() {
    synchronized(this) {
      dodo = false
notifyAll();
    }
  }  
 
}

et si c'est un code à répetition tu peus simplement englober le code de ton run dan sun while(true) je sais que c'est moche mais ce n'est pas le but de l'explication ici.

[Pill_S]

Merci beaucoup, fxjtarga, de réveiller les vieux posts de presque une année et qui devait se trouver au moins en page 60 du forum !!

pour tout te dire, j'ai fait beaucoup de progrès depuis cette époque, et le multi-thread n'est plus un problème pour moi

mais merci quand même !

[fxjtarga]

arfeu oki j'avais pas vu ni fait attention a la date du post je suis arriver via un lien poster dans la rebrique participer de la faq ,,,