Arrêter un thread par son nom

Version imprimable

Bonjour,
Je cherche comment chercher et arrêter un thread par son nom.
Ci dessous j'ai deux classes avec deux main.
La première lance un thread avec le nom "MyThread0".
La deuxième, utilisant l'api "commons-lang3", cherche ce thread par son nom et essaies de l’interrompre.
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 package com.threads; import java.util.Date; class MyThread extends Thread{ public MyThread(String name) { this.setName(name); } @Override public void run() { int i = 20; while(i > 0){ System.out.println("Thread ["+Thread.currentThread().getThreadGroup().getName()+" , "+this.getId()+" , "+ this.getName()+"] :" + new Date()+ " Boucle infinie !"); } } } public class MainTh1 { public static void main(String[] args) { MyThread m = new MyThread("MyThread0"); m.start(); } }
J'exécute MainTh1
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 package com.threads; import java.util.Collection; import org.apache.commons.lang3.ThreadUtils; public class MainTh2 { public static void main(String[] args) { Collection<Thread> liste = ThreadUtils.findThreadsByName("MyThread0"); System.out.println(liste.size()); if(liste!=null && !liste.isEmpty()){ for(Thread t : liste){ t.interrupt(); } } } }
J'exécute MainTh2
MainTh2 ne trouve aucun thread avec le nom "MyThread0", alors qu'il est déjà en exécution (Boucle infinie).
Comment je peux arrêter mon thread à partir de MainTh2 ?

Merci pour votre retour.

21/03/2018, 14h42
Drowan

Je pense que comme tu lance 2 programmes différents tu obtiens 2 process diférents. Ils ne partagent pas donc pas le même contexte. Ton main 2 n'as pas accès à ton MyThread0, il ne le connait pas/ne le voit pas.
C'est donc normal qu'il ne le trouve pas.

Je pense que si tu appelle findThreadsByName() depuis ton main1 tu doit obtenir ton thread

Salut,

Attention interrupt() ne fait que changer un état (pour certaines méthodes on obtiendra une exception), mais le thread ne s'arrêtera pas pour autant s'il ignore ce changement d'état.

Thread non interruptible

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
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			while(true) {
				System.out.println("Thread is running...");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) { 
				}
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

Thread non interruptible :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			while(true) {
				System.out.println("Thread is running...");
				long time=System.currentTimeMillis();
				while( System.currentTimeMillis()-time<500 ) Thread.yield();
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

Thread non interruptible:

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
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			for(int i=0; i<1000; i++) {
				System.out.println("Thread is running..."+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {  
				}
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

Thread interruptible :

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
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			while(true) {
				System.out.println("Thread is running...");
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) { 
					break;
				}
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

Thread interruptible :

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
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			for(int i=0; i<1000; i++) {
				System.out.println("Thread is running..."+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) { 
					break;
				}
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

Thread interruptible :

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
public static void main(String[] args) {
 
		Thread thread = new Thread(()-> {
 
			for(int i=0; i<1000; i++) {
				System.out.println("Thread is running..."+i);
				long time=System.currentTimeMillis();
				while( System.currentTimeMillis()-time<500 ) {
					if ( Thread.currentThread().isInterrupted() ) {
						System.out.println("Interrupted");
						i=1000;
						break;
					}
					Thread.yield();
				}
			}
 
 
		});
		thread.start();
 
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) { 
		}
		System.out.println("Interrupt thread");
		thread.interrupt();
 
	}

21/03/2018, 15h33
kodo

Merci pour vos retours.
Donc si j'ai bien compris, il y a aucun moyen de stopper un thread contenu dans un thread différent ?

Il faut le gérer à la main.

Si une instruction permettait de couper un thread en plein dans l'exécution d'une instruction. Cela pourrait avoir des effets néfastes.

Un thread qu'on peut couper, c'est souvent qu'il a une pile de travail.
Et cela ressemble un peu à ce genre de "truc":
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 Blabla implements Runnable { private boolean stopIsRequested = false; public boolean doTask() throws Exception; public void run() { try { while(!stopIsRequested) { if(!doTask()) { break; } } } catch(Throwable t) { LOGGER.error(t.getMessage(), t); } } public void stop() { stopIsRequested =true; }

22/03/2018, 00h38
kodo

Merci pour les réponses.
Je vais vous expliquer ce que je cherche derrière tous cela.
J'ai une table dans ma base de données. Chaque ligne de cette table correspond à une demande de lancement d'un batch (exécution d'une requête prédéfinie et écriture de résultat dans un fichier csv, xl, txt) (Exemple de requête : select a.id, a.nom.. from table a where a.date=?...).
Mon application Java (que je développe) consiste à lire dans cette table et lancer le batch correspondant dans un thread (pour l’exécution parallèle des batchs).
La question que je me posais et d'ailleurs l'objet dérriere cette discussion, est de savoir la possibilité de stopper un thread qui exécute un batch.

J'espère que j'étais clair. Je ne sais pas si je me procède de la bonne façon ou non?

Mes excuses aux modérateurs si cette discussion concerne un autre sous forum.
22/03/2018, 00h52
joel.drigo

Mais c'est quoi ton batch ? Un programme externe ?
22/03/2018, 11h01
kodo

Je développe avec Spring batch
22/03/2018, 11h16
joel.drigo

Je ne connais pas vraiment Spring Batch, mais il doit y avoir un support pour annuler un job (voir JobOperator...).
23/03/2018, 03h44
bouye
Je rappelle aussi a toutes fins utiles que la classe Thread dispose de 2 (!) méthodes pour tester si elle a été interrompue en invoquant interrupt() donc pas trop besoin de mettre son propre sémaphore en fait :
- isInterrupted() - renvoie le statu d'interruption ;
- interrupted() - renvoie le statu d'interruption et le réinitialise(danger)
Du coup quand on est dans un Runnable :
Code:

1 2 3 while (!Thread.currentTread().isInterrupted()) { // ... }
28/03/2018, 00h20
tchize_

pour autant que tes steps dans spring batch ne tournent pas pendant des heures, spring batch gère déjà tout ce qu'il faut via le joboperator. Si t'as arrêté le batch, la step suivante ne démarrera pas.