[Thread] Recuperer le Thread qui s'execute dans la methode run()

**facilus68** · 06/02/2009, 10h54

Bonjour,

J'ai un Thread qui lance la methode run(), lorsque je veux mettre en pause ce qui s'execute dans methode run(), je fais un wait(1000) en dehors du run() mais ca met pas en pause, mais si je fait le wait a l'interieur de la methode run() sa fonctionne.

je voudrais controller le pause a l'exetrieur de la methode run() (pas de test dedans) ce qui ma mener a penser a recuperer le thread correspondant mais j'arrive pas malheuresment.

voici la partie du code :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
public void run() {
		int i = 0;
		while (true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("le compteur est = " + i);
			i++;		
 
		}
	}
}
 
public void pause() throws InterruptedException {
		synchronized (this) {
			this.wait(5000);
			System.out.println("le thread est en pause");
		}
	}
 
	public void resume() {
		synchronized (this) {
			this.notifyAll();
		}
	}
 
public static void main(String[] args) throws InterruptedException {
 
		TestThread test = new TestThread();
		Thread th = new Thread(test);
 
		th.start();
 
		Thread.sleep(3000);
 
               // 1er test
                test.pause();
                test.resume();
 
 
              // 2eme test
               synchronized (th) {
			th.wait(5000);
			System.out.println("le thread est en pause");
		}
		synchronized (th) {
			th.resume();
			System.out.println("le thread a repris");
		}

Merci pour votre aide.

**adiGuba** · 06/02/2009, 11h42

Salut,

La méthode wait() doit être utilisé pour la synchronisation, et endors le thread appelant (et non pas l'objet sur lequel la méthode est utilisé).

Tu ne peux pas endormir un thread depuis un autre thread. C'est ce que faisait les méthodes déprécié suspend()/resume(), mais elles sont dangereuse car du coup elles peuvent laisser le thread dans un état incohérent qui pourrait impacter les autres threads et provoquer des erreurs aléatoires...

En fait un thread DOIT s'endormir de lui même, afin d'être sûr qu'il soit dans un état correct. Et tout ce que tu peux faire c'est donc lui demander de bien vouloir s'endormir...

Tout cela nécessite un peu de synchronisation mais ce n'est pas bien compliqué :

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
39
40
41
42
43
44
45
46
47
48
class PauseableThread extends Thread {
 
	private final Object pausedLock = new Object();
	private boolean paused = false;
 
 
	public boolean isPaused() {
		return this.paused;
	}
 
	public void setPaused(boolean paused) {
 
		// Si la valeur est modifié :
		if (this.paused != paused) {
			// On rentre dans le bloc synchronisé :
			synchronized(this.pausedLock) {
				// On met à jour la valeur :
				this.paused = paused;
				// Et on notify le thread si on sort de la pause
				if (this.paused==false) {
					this.notify(); // permet de sortir du wait()
				}
			}
		}
 
 
 
	}
 
	/*
	 * Cette méthode doit être appelé à intervalle régulier par le thread :
	 */
	private void checkPaused() throws InterruptedException {
		// Si on est en pause :
		if (this.paused) {
			// On rentre dans le bloc synchronisé :
			synchronized(this.pausedLock) {
				// Et on attend une notification de fin de pause
				// (le while() permet d'éviter les "faux réveils"
				while (this.paused) {
					this.wait();
				}
			}
		}
 
	}
 
}

La méthode setPaused() permet de modifier l'état "paused" du thread, qui est juste un état à titre informatif.

Dans la méthode run(), il faudra effectuer à "intervalles réguliers" des appels à la méthode checkPaused() qui vérifiera son état "paused" et se mettra en pause si besoin...

a++