Discussion :

[freddy766]

Bonjour à tous,

j'aimerai arreter un process au bout d'un temps donné. Pour ceci j'utilise la class Thread et le programme suivant:

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
 
class Exemple1 extends Thread {
 
	  public void run () {
		  while(true){
	    System.out.println ("Bonjour de " + this);
		  }
	  }
 
	  public static void main (String[ ] args)
	    throws InterruptedException {
	    Thread t = new Exemple1();
	    t.start();
	    t.join(1000);
	  }
	}

Normalement au bout de 1000 ms le process doit s'arreter... et pourtant le process tourne toujours et m'affiche encore le contenu du

Code :

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

 System.out.println

. Est-ce que quelqu'un a déja rencontré ce prb?
Merci
Freddy

[adiGuba]

Salut,


C'est normal puisque tu as deux threads :

• Le thread principal (celui qui exécute le main).
• Ton thread perso représenté par la classe Exemple1 qui tourne en boucle

Donc ton code le join() bloquera le thread main pendant 1 seconde en attendant que le thread "exemple1" se termine (ce qui ne sera jamais le cas).

Au bout d'une seconde tu sors du join() et ton thread main est terminé, mais par contre ton thread "exemple1" continue à tourner librement...


Pour l'arrêter tu as trois solution :

1. Quitter le programme, et rajouter un System.exit(0) juste après le join(). Cela terminera tout les threads de l'application sans distinction...
   
   
2. Terminer ton thread proprement, c'est à dire en lui envoyant une interruption juste après le join() :
   

   Code :

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

   1
   2
   	    t.join(1000);
   	    t.interrupt();

   Pour cela il faut bien sûr gérer les interruptions dans ta méthode run() :
   

   Code :

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

   1
   2
   3
   4
   5
   	  public void run () {
   		  while(!isInterrupted()){
   			  System.out.println ("Bonjour de " + this);
   		  }
   	  }

   
   
3. Enfin dernière solution : utiliser un thread daemon.
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   	  public static void main (String[ ] args)
   	    throws InterruptedException {
   	    Thread t = new Exemple1();
   	    t.setDaemon(true);
   	    t.start();
   	    t.join(1000);
   	  }

   Un thread daemon ne modifie pas la durée de vie de l'application : lorsque le dernier thread non-daemon est terminé, tous les threads daemon sont automatiquement terminé (ainsi que l'application).

a++

[freddy766]

Merci,

génial! Je vais priviligier la solution 2 car la solution 3 peut être couteuse dans le cas où j'ai beaucoup de process qui vont tourner en parallèle en attendant la fin du prg général.

Evore un grand merci.
Freddy.

[freddy766]

Imaginons un cas un peu plus vicieux:

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
 
class Exemple1 extends Thread {
 
	  public void run () {
		  while(!isInterrupted()){
			  for(int i =0; i<100000; i++){
				  System.out.println(i);
			  }
		  }
	  }
 
	  public static void main (String[ ] args)
	    throws InterruptedException {
	    Thread t = new Exemple1();
	    t.start();
	    t.join(1000);
	  }
	}

Dans ce cas la, j'aimerai stopper le thread au bout de 1000 ms mais celui-ci attend que la boucle s'effecture (ce qui est normal). Cependant comment arreter ce thread 1000 ms après, sans donc attendre que la boucle s'effectue.

Comme indiqué précedemment on peut faire un System.exit(0); juste après. Mais cela stoppe tout et donc impossible de faire autre chose ensuite. Aves vous une solution pour ce cas d'usage?

Merci.
Freddy

[gifffftane]

Il n'existe pas de réponse générale à ce cas là. La meilleure solution est ce que tu as fait, et ce qu'à dit adiGuba.

Le cas que tu soulèves arrive souvent lorsque le thread reste bloqué en lecture ou en attente de quelque chose, par exemple une ressource comme un lecture de socket, de flux... En ce cas, soit l'opération bloquante supporte elle même l'interrupt, et on en revient à ton cas de figure, soit on ferme le service d'un autre thread, ce qui provoque (à ma connaissance, dans tous les cas, ce qui est une chance, il faut le reconnaître), la sortie d'attente sur une exception.

Par exemple, sur lecture d'un flux le 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
 
 
public void run()
{
try
{
 String ligne = reader.readLine();
 while (ligne != null)
 {
  buffer.append(ligne+'\n');
  ligne = reader.readLine();
 }
 // fin normale du thread de lecture.
}
catch (IOException bing)
{
 ... fin du thread sur close externe...
}
}

D'un thread extérieur, par exemple si c'est trop long :

Code :

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

1
2
 
 reader.close();

... provoquera un IOException et donc la sortie immédiate du thread.

[adiGuba]

On peut également multiplier les vérifications de l'état du thread :

Code :

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

1
2
3
4
5
6
7
	  public void run () {
		  while(!isInterrupted()){
			  for(int i =0; i<100000 && !isInterrupted(); i++){
				  System.out.println(i);
			  }
		  }
	  }

a++