Java et séquencement des threads

Salut,

Le titre du sujet décrit mon probléme : J'ai deux threads qui s'éxécutent en arriére plan mais je veux que le deuxiéme thread attend la fin du premier avant de commencer sans traitement .

La situation que je veux avoir est celle là :
Code:

1 2 3 4 5 Thread1Class t1 = new Thread1Class(); t1.start(); attendre la fin de t1 Thread1Class t2= new Thread1Class(); t2.start();
Comment pourrai-je avoir cette situation ?

Merci

Plop,

Deux solutions s'offrent à toi.

La première serait de lancer directement le second thread dans le premier. A la fin du traitement du premier, tu lances le deuxième et laisse le premier mourir.

La seconde solution est d'utiliser wait / notify. Tu mets le premier thread en wait dès son démarrage et tu fais un notify à la fin du second.

La première solution t'évites de créer un thread qui est inutile puisque dépendant du second.

Salut,

un troisième solution possible, appeler la méthode join() de la classe Thread sur le premier thread, dans le second

exemple :

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
public class ExempleThreadJoin {
 
	public static void main(String[] args) {
		final Thread thread1 = new Thread() {
			public void run() {
				println("thread1 start");
				try {
					sleep(2000);
				     println("thread1 end");
				} catch (InterruptedException e) {
				     println("thread1 aborted");
				}
			}
		};
		Thread thread2=new Thread() {
			public void run() {
				try {
					thread1.join();
					println("thread2 start");
					sleep(2000);
					println("thread2 end");
				} catch (InterruptedException e) {
					println("thread2 aborted");
				}
			}
		};
		thread2.start();
		thread1.start();
	}
 
	protected static synchronized void println(String string) {
		System.out.println(System.currentTimeMillis()+" "+string);		
	}
 
}

une quatrième méthode est d'utiliser un CountdownLatch :

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
public class ExempleCountDownLatch {
 
	public static void main(String[] args) {
		final CountDownLatch cdl = new CountDownLatch(1);
		Thread thread1 = new Thread() {
			public void run() {
				try {
					println("thread1 start");
					try {
						sleep(2000);
					        println("thread2 end");
					} catch (InterruptedException e) {
						println("thread2 aborted");
					}
				}
				finally {
					cdl.countDown();
				}
			}
		};
		Thread thread2=new Thread() {
			public void run() {
				try {
					cdl.await();
					println("thread2 start");
					sleep(2000);
					println("thread2 end");
				} catch (InterruptedException e1) {
					println("thread2 aborted");
				}
			}
		};
		thread2.start();
		try {
			thread1.start();
		}
		catch (Throwable t) {
			thread2.interrupt();
		}
	}
 
	protected static synchronized void println(String string) {
		System.out.println(System.currentTimeMillis()+" "+string);		
	}
 
}

c'est 2 méthodes obligeant de démarrer le second thread et de le mettre en attente, la meilleure méthode à mon avis est la première décrite par @olivier.pitton

mais si le but est de séquencer 2 processes une autre solution est d'utiliser un service d'execution :

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
public class ExempleExecutorService {
 
	public static void main(String[] args) {
 
		final Runnable task1 = new Runnable() {
			public void run() {
				try {
				     println("task1 start");
					Thread.sleep(2000);
				        println("task1 end");
				} catch (Throwable t) {
					t.printStackTrace();
				      	println("task1 aborted");			     
				}
			}
		};
		Runnable task2 = new Runnable() {
			public void run() {
				try {
 				    println("task2 start");
					Thread.sleep(2000);
				    println("task2 end");
				} catch (Throwable t) {
					println("task2 aborted");
				}
			}
		};
 
		ExecutorService service = Executors.newSingleThreadExecutor();
 
		service.execute(task1);
		service.execute(task2);
 
		service.shutdown();
 
	}
	protected static synchronized void println(String string) {
		System.out.println(System.currentTimeMillis()+" "+string);		
	}
 
}

toutefois cette solution a un défaut la second tache s'éxécute même si la première plante, même dès le départ

on peut faire ce genre de truc (là c'est juste un exemple de principe, il vaudrait mieux créer une vraie classe public Task, avec un moyen pour une tache de connaitre la tache précédente et son statut)

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
public class ExempleExecutorService {
 
	public static void main(String[] args) {
 
		class Task1 implements Runnable {
 
			public volatile boolean ok;
 
			public void run() {
				try {
					println("task1 start");
					Thread.sleep(2000);
					println("task1 end");
					ok=true;
				} catch (Throwable t) {
					t.printStackTrace();
				}
			}
 
		}
 
		final Task1 task1 = new Task1();
 
		Runnable task2 = new Runnable() {
 
			public void run() {
				if ( task1.ok ) {
					try {
						println("task2 start");
						Thread.sleep(2000);
						println("task2 end");
					} catch (Throwable t) {
						t.printStackTrace();
					}
				}
			}
		};
 
		ExecutorService service = Executors.newSingleThreadExecutor();
 
		service.execute(task1);
		service.execute(task2);
 
		service.shutdown();
 
	}
 
	protected static synchronized void println(String string) {
		System.out.println(System.currentTimeMillis() + " " + string);
	}
 
}