Discussion :

[Virgile le chat]

Bonjour,
Je me prends la tête avec les thread comme c'est pas permis !
J'ai plein de questions. En voilà une :
Je voudrais pouvoir interrompre et reprendre l'exécution d u thread interrompu. Il y a bien les méthodes suspend et resume mais elles sont "deprecated". Y a t il des équivalents ?
Je demande cela car apparemment il n'y a pas de méthode pour reprendre l'exécution d'un thread interrompu par interrupt()...
Merci bien.

[CyberChouan]

Dans ce genre de cas le mieux est de créer toi-même un thread interruptible, avec un flag (si l'action de ton Thread est cyclique).

Voici un exemple d'implémentation (il te faudra évidemment ajouter des accesseurs sur les booléens running et finished pour pouvoir contrôler ton 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
 
public class ThreadInterruptible extends Thread {
 
   private boolean running = false;
   private boolean finished = false;
 
   public void run() {
      while(!finished) {
         if(running) {
            // action du Thread
         } else {
            Thread.wait(1000); // attente de 1 seconde avant de tester
            // si l'action doit reprendre
         }
      }
   }
}

[Virgile le chat]

merci bien

[®om]

Pour éviter une attente active avec un Thread.sleep(1000) (en passant Thread.wait n'existe pas en static), il faut utiliser des mécanismes de synchronisation :

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
public class PausableThread extends Thread {
 
	private boolean paused;
 
	@Override
	public void run() {
		try {
			// du code
			pauseIfNeeded(); // bloquant sans utiliser le processeur si le thread doit être en pause
			// du code
		} catch (InterruptedException e) {}
	}
 
	public synchronized void pause() throws InterruptedException {
		paused = true;
	}
 
	public synchronized void unpause() {
		paused = false;
		notify();
	}
 
	private synchronized void pauseIfNeeded() throws InterruptedException {
		if (paused) {
			wait();
		}
	}
 
}

Après dans le code de ton run() tu mets des pauseIfNeeded() aux endroits où tu veux que le thread se bloque en attendant un unpause()...

[CyberChouan]

Pour éviter une attente active avec un Thread.sleep(1000) (en passant Thread.wait n'existe pas en static)

oups... effectivement, j'ai tapé le code en direct un peu vite, et j'ai confondu les deux noms de méthode. Merci pour la rectification (et pour l'optimisation que tu as proposée)