Discussion :

[kodo]

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 :

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

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

[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

[joel.drigo]

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 :

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

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

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

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

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

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

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

[millie]

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 :

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

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

[joel.drigo]

Mais c'est quoi ton batch ? Un programme externe ?

[kodo]

Je développe avec Spring batch

[joel.drigo]

Je ne connais pas vraiment Spring Batch, mais il doit y avoir un support pour annuler un job (voir JobOperator...).

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

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

1
2
3
while (!Thread.currentTread().isInterrupted()) {
  // ...
}

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