Thread problème de mise en pause dans des éléments Swing

Version imprimable

J'ai testé le code suivant en suivant d'ailleurs un totu du site, qui me dit que les élémens graphgiques doivent être exécutés dans l'EDT, donc j'ai mis tout ce qui concerne la réactualisation graphique dans des SwingUtilities.invokeLater(...)

Je veux que mon Thread Calcul (la classe Calcul étend Thread) se stoppe lors de l'appui sur le bouton

Voici mon code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public void run() { final int [] finalInt =new int[1]; finalInt[0]=nombre; while(true) { finalInt[0]++; Runnable code=new Runnable() { public void run() { essai.getLabel().setText("The Number is : "+finalInt[0]); } }; try{ SwingUtilities.invokeAndWait(code); }catch(InvocationTargetException ite) {ite.printStackTrace();} catch(InterruptedException ie) {ie.printStackTrace();} essai.setNombre(finalInt[0]); } }
L'interface graphique comporte des boutons :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public void actionPerformed(ActionEvent arg0) { if(arg0.getActionCommand().equals("Start")) { calcul.start(); } if(arg0.getActionCommand().equals("Pause")) { synchronized(calcul) { try{ wait(); }catch(InterruptedException ie) {ie.printStackTrace();} } } if(arg0.getActionCommand().equals("ReStart")) { synchronized(calcul) { calcul.notify(); } } }
Il n'y a pas de messages d'erreurs en faisant start puis pause, mais le Thread ne s'arrête pas et continue de s'exécuter.
Quelqu'un pourrait-il me donner un coup de main pour comprendre le problème?
Merci vivement d'avance :-)

21/08/2008, 15h52
Balbuzard

N'y a-t-il vraiment personne pour me donner un coup de main?

...
21/08/2008, 16h13
DjGonk

Simple remarque tu veux mettre en pause le thread ou l'arreter définitivement?

Sinon le en regardant ton code je vois que le wait ne concerne pas ton thread calcul mais plutôt ton ihm.
21/08/2008, 16h23
fr1man

http://java.sun.com/j2se/1.4.2/docs/...precation.html

Jette un oeil à ce lien, tu devrais y trouver ton bonheur.
22/08/2008, 10h31
barbiche

Je vois deux façons de faire :
- méthode bourrin : tonThread.interrupt();
- sinon utiliser un SwingWorker (ce qui est nettement plus propre)
22/08/2008, 16h15
Balbuzard
@ DjGonk: En fait, je veux le mettre en pause jusqu'à ce que l'utilisateur le remettre en route à l'aide d'un autre bouton. Donc le Thread calcul se met en wait() et est réveillé par le Thread courant exécuté lors de l'appuis sur la touche par l'utilisateur.

J'ai aussi l'impression que mon Thread ne se stope pas parce que je ne mets pas le wait au bon Thread, mais je ne wait pas l'IHM non plus, car elle reste réactive.

C'est bien là, mon problème, je ne sais pas comment faire pour que la machine comprenne que c'est sur le Thread calcul que je souhaite agir.

Si je mets:
Code:

1 2 3 4 5 6 7 8 if(arg0.getActionCommand().equals("Pause")) { synchronized(calcul) { try{ calcul.wait(); }catch(InterruptedException ie) {ie.printStackTrace();} } }
alors, lorsque calcul entre dans le bloc synchronized, il se met en wait et plus aucun Thread ne peut faire quoique ce soit, car calcul est en wait, et du fait du synchronized, les autres attendent qu'il ait terminé!!

Si quelqu'un voit une façon de faire, ce serait cool.
Quant à moi, je vais voir les SwingWorker et le tutoriel sun comme me le suggèrent barbiche et fr1man

Merci pour vos réponses :-)

Code:

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
@SuppressWarnings("serial")
public class Test extends JFrame implements ActionListener {
 
	private Task task = new Task();
 
	public Test() {
		super();
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
 
		JButton startButton =new JButton("Start");
		startButton.setActionCommand("Start");
		startButton.addActionListener(this);
 
		JButton pauseButton =new JButton("Pause");
		pauseButton.setActionCommand("Pause");
		pauseButton.addActionListener(this);
 
		JButton canceButton =new JButton("Cancel");
		canceButton.setActionCommand("Cancel");
		canceButton.addActionListener(this);
 
		JPanel panel = new JPanel();
		panel.add(startButton);
		panel.add(pauseButton);
		panel.add(canceButton);
 
		this.add(panel);
		this.pack();
	}
 
	@Override
	public void actionPerformed(ActionEvent actionEvent) {
		if(actionEvent.getActionCommand().equals("Start")) {
			System.err.println("Start");
			task.start();
		} else if(actionEvent.getActionCommand().equals("Cancel")) {
			System.err.println("Cancel");
			task.stop();
		} else {
			System.err.println("Pause");
			if(task.isPaused()) {
				task.unpause();
			} else {
				task.pause();
			}
		}
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			@Override
			public void run() {
				JFrame jFrame = new Test();
				jFrame.setVisible(true);
			}
		});
	}
 
	private static class Task implements Runnable {
 
		private volatile Thread thread;
		private volatile boolean paused;
 
		public void start() {
			thread = new Thread(this);
			thread.start();
		}
 
		public void stop() {
			thread = null;
		}
 
		public void pause() {
			this.paused = true;
		}
 
		public void unpause() {
			this.paused = false;
			if(this.thread != null) {
				synchronized(this.thread) {
					this.thread.notify();
				}
			}
		}
 
		public boolean isPaused() {
			return this.paused;
		}
 
		@Override
		public void run() {
			final Thread currentThread = Thread.currentThread();
			while(currentThread == this.thread) {
				try {
					System.out.println("execute");
	                Thread.sleep(1000);
	            } catch (InterruptedException e){
	            	System.err.println("The thread has been interrupted");
	            }
 
	            if(this.thread != null) {
		            synchronized(this.thread) {
		            	while(this.paused) {
		            		try {
		            			this.thread.wait();
							} catch (InterruptedException e) {
								System.err.println("The thread has been interrupted");
							}
		            	}
		            }
	            }
			}
		}
	}
}

25/08/2008, 09h54
Balbuzard

Merci beaucoup pour ta réponse que je suis en train de tester;

Je suis notamment en train de le réadapter pour qu'il prenne en compte les modifications graphiques et tout se passe NICKEL.
J'ai enfin pu trouver une réponse pour mes soucis de Threads et je crois que je suis en train de m'en sortir :-D

Merci encore :-)