Discussion :

[thedev44]

Bonjour,

Mon programme comporte 2 classes avec un main chacun (je ne sais pas s'il est courant de le faire). L'une des classes correspond à un ihm avec 2 boutons (démarrer et arrêter) qui démarre et arrête l'autre classe. Pour démarrer c'est ok mais pour arrêter je n'y arrive pas.
J'ai essayé avec le System.exit(0); mais ça m'arrête l'ihm et donc tout.

J'ai essayé de faire un stop() sur le thread, au clic sur démarrer ça lance, au clic sur arrêter ça arrête mais au reclic sur démarrer ça me lance une exception:
Exception in thread "AWT-EventQueue-0" java.lang.IllegalThreadStateException

[joel.drigo]

Salut,

Tout d'abord, la méthode main() est le moyen de démarrer un programme. Peu importe le nombre de classes, si tu as plusieurs main() c'est que tu as plusieurs moyens de démarrer ton programme (depuis l'extérieur s'entend). Si tu démarres ton programme et qu'il affiche une fenêtre avec 2 boutons pour démarrer et arrêter quelque chose à l'intérieur de ce programme, il est inutile d'avoir une méthode main pour ça. Mais on peut si on veut.

Ensuite, ne jamais utiliser la méthode stop() de Thread.

Pour ce qui est de l'arrêt de ton processus, il y'a plusieurs solutions, qui dépendent de ce que c'est. S'il s'agit d'une fenêtre (JFrame), il suffit de la fermer, par appel de sa méthode dispose(). S'il s'agit d'un thread avec une boucle de type while(true), il suffit de remplacer le true par une variable booléenne, qu'on initialise à true au démarrage, et de faire une méthode qui la passe à false. La variable devra être volatile pour pouvoir avoir un arrêt instantané.

Par exemple :

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
public class Launcher {
 
	private final JButton demarrer;
	private final JButton arreter;
 
	private Programme programme;
 
	public Launcher() {
		JFrame frame = new JFrame("Mon programme");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		demarrer = new JButton("Démarrer");
		demarrer.addActionListener(e-> demarrer());
 
		arreter = new JButton("Arrêter");
		arreter.setEnabled(false);
		arreter.addActionListener(e-> arreter());
 
		JPanel panel = new JPanel();
		frame.add(panel);
 
		panel.add(demarrer);
		panel.add(arreter);
 
		frame.addWindowListener(new WindowAdapter() {
 
			@Override
			public void windowClosed(WindowEvent e) {
				super.windowClosed(e);
				if ( programme!=null ) {
					programme.arreter();
				}
			}
		});
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private void demarrer() {
		demarrer.setEnabled(false);
		programme = new Programme();
		new Thread(programme).start();
		arreter.setEnabled(true);
	}
 
	private void arreter() {
		arreter.setEnabled(false);
		programme.arreter();
		demarrer.setEnabled(true);
	}
 
	public static void main(String[] args) {
 
		new Launcher();
 
	}
 
}

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 Programme implements Runnable {
 
	private volatile boolean run = true;
	private volatile Thread runningThread;
 
	public void arreter() {
		run=false; 
		if ( runningThread!=null ) {
			runningThread.interrupt();
		}
	}
 
	@Override
	public void run() {
                if ( runningThread!=null ) throw new IllegalStateException();
		runningThread = Thread.currentThread();
		System.out.println("Je démarre");
		while(run) {
			System.out.println("Je fonctionne");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Je m'arrête");
	}
 
 
}

On pourrait faire comme ça aussi, ce qui rend l'instance de Programme réutilisable (après arrêt) :

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
public class Programme implements Runnable {
 
	private volatile Thread runningThread;
 
	public void arreter() {
		if ( runningThread!=null ) {
			runningThread.interrupt();
			runningThread=null;
		}
	}
 
	@Override
	public void run() {
		if ( runningThread!=null ) throw new IllegalStateException();
		runningThread = Thread.currentThread();
		System.out.println("Je démarre");
		while(runningThread!=null) {
			System.out.println("Je fonctionne");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Je m'arrête");
	}
 
}

Même si le programme est démarré par appel d'une méthode main(), tu peux mettre en place un mécanisme similaire. Si ton programme n'est pas une boucle, il faudra prévoir des points de sortie, c'est un peu plus fastidieux.

Il y a une autre option : démarrer le second programme comme un programme externe, avec la classe ProcessBuilder, qui te permettra de tuer le processus. Mais il te faudra faire référence à cette classe directement comme un programme externe (via la commande java.exe et un .class ou un .jar, qui peut être le jar qui contient les deux classes au final).

[bouye]

Et aussi vérifier la valeur retournée par isInterrupted() car catcher une InterruptedException c'est bien joli mais c'est uniquement valable sur les méthodes susceptibles d'en lancer une.

PS : la méthode statique Thread.interrupted() fonctionne aussi mais cette méthode réinitialise la valeur du flag contrairement a la méthode d'instance isInterrupted().

[thedev44]

Merci beaucoup joel.drigo, j'ai réussi grâce à ton exemple
Maintenant j'ai un autre problème moins méchant: dans mon programme j'utilise des socket et on peut démarrer avant que l'ancienne se termine du coup ça fait buguer si on clic sur démarrer avant la fin du précédent. Merci beaucoup

[joel.drigo]

Déjà, ce serait pas mal si j'avais plus de précision sur "ça fait bugué", qui veut tout dire et rien dire à la fois. Serait-ce un problème de socket pas fermée ? Toujours est-il qu'avec un message d'erreur et/ou un stacktrace, et un peu de code, j'y verrai le miminum nécessaire pour te repondre.
Il me faudrait savoir également que fait la méthode "arrêter" : en théorie, elle ne devrait rendre la main que quand le processus est réellement fini, afin d'activer le bouton seulement à ce moment. Cependant, comme rien ne peut garantir que l'UI soit effectivement à jour, il faudra de toute manière tester l'état pour éviter de démarrer 2 process simultanément si ton système ne le supporte pas, quelque soit l'état de l'UI.

[thedev44]

Merci beaucoup, tes suggestions m'ont permis de résoudre, c'était du code mal placé