Discussion :

[el3gans]

Bonjour,
J'ai un sérieux probleme avec les threads.

Voilà j'ai un algorithme qui prend pas mal de cpu, alors je me suis dit pourquoi pas le mettre dans un thread et ainsi pouvoir le mettre en pause et le reveiller a ma guise.

Pour cela j'ai crée une classe comme ceci.

Code :

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

1
2
3
4
5
6
7
8
 
public class CalculMoiCa extends Thread{
 
 // j'ai que la methode run
	public void run() {
             //un algo de calcul bien long.
        }
}

ensuite dans mon interface swing qui est dans une autre class, à l'aide de quelques boutons j'effectue

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
 
 
private CalculMoiCa viite = null;
 
// ...
 
public void actionPerformed(ActionEvent e) {
 
		JButton b = (JButton)e.getSource();
 
		if (b == this.bStart) {
			System.out.println("start");
			viite = new CalculMoiCa();
			viite.start();
			return;
		}
		if (b == this.bResume) {
			System.out.println("resume");
			viite.notifyAll();
			return;
		}
		if (b == this.bPause) {
			System.out.println("pause");
			viite.wait();
			return;
		}
	}

Mais bien entendu ca ne marche pas :/

J'ai surement pas compris quelque chose.

Merci à l'avance pour votre aide.

[trimok]

C'est une mauvaise utilisation des méthodes wait () et notify ()

1) La méthode wait () ne permet pas d'interrompre une thread de l'extérieur, c'est, typiquement, une thread qui décide d'appeler une méthode verrou.wait () sur un objet verrou, ce qui interrompt le code de la thread jusqu'à ce qu'une autre thread (ou la même) lève ce verrou par verrou.notify ()

2) Bien que la classe Thread dérive de la classe Object, et donc possède les méthodes wait/notify, l'utilisation standard de ces méthodes se fait avec des objets verrous (pas des threads), et uniquement dans des méthodes synchronisées sur ces objets verrous.

Pour ton problème, le plus simple est d'utiliser un flag.
Voici un petit programme test, que tu pourras adapter à ton cas:
(Regarde bien - c'est important - la méthode yield (), qui permet de laisser la main aux autres (threads) pour que tout le monde puisse travailler.....)

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
public class ThreadTest
{
 
	/**
         * @param args
         */
	public static void main (String[] args)
	{
		// Création de l'objet thread
		ThreadTest tt = new ThreadTest ();
		Thread1 t1 = tt.new Thread1();
 
		// Démarrage de la thread
		t1.start();
 
		// La suite est un programme de test
 
		// Tant que la thread est vivante
		while (t1.isAlive())
		{
			// Le flag de fonctionnement de la thread est mis à faux
			t1.setFlagOk(false);
 
			// On laisse la main aux autres (threads)
			t1.yield ();
 
			// Le flag de fonctionnement de la thread est remis à vrai
			t1.setFlagOk(true);					
		}
	}
 
	// La classe thread
	class Thread1 extends Thread
	{
		// Le flag de fonctionnement de la thread
		private boolean flagOk = true;
 
		// Le "setter"
		public void setFlagOk (boolean flagOk)
		{
			this.flagOk = flagOk;
		}
 
		public void run ()
		{
			traitementGlobal ();
		}
 
		// Le traitement global se décompose en un ensemble d'étapes
		public void traitementGlobal ()
		{
			for (int i = 0; i < 100; )
			{
				// Si c'est OK, on effectue le traitement de l'étape
				if (flagOk)
				{
					traitementEtape (i);
					i++;
				}	
				// Sinon on attend
				else
				{
					attenteEtape (i);
				}
			}							
		}
 
		public void traitementEtape (int i)
		{
			System.out.println ("Etape " + i);
		}
 
		public void attenteEtape (int i)
		{
			System.out.println ("Thread stoppée à l'étape " + i);
 
			// On laisse la main aux autres (threads)
			yield ();
		}				
	}		
}

[el3gans]

J'ai resolu le problème en me servant des sémaphores
merci.