Discussion :

[Balbuzard]

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 :

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()
	{
		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 :

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
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 :-)

[Balbuzard]

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

...

[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.

[fr1man]

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

Jette un oeil à ce lien, tu devrais y trouver ton bonheur.

[barbiche]

Je vois deux façons de faire :
- méthode bourrin : tonThread.interrupt();
- sinon utiliser un SwingWorker (ce qui est nettement plus propre)

[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 :

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

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 :-)

[darkxan]

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
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");
							}
		            	}
		            }
	            }
			}
		}
	}
}

[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 :-)