[Thread] Un père qui doit attendre la fin des fils

Version imprimable

Salut à tous et à toutes :)

j'essaye de synchroniser un groupe de thread (classe MyThread) pour obtenir le fonctionnement suivant :
le thread principal crée 5 thread qui affichent un simple message, puis affiche à son tour un message..
j'insiste sur le fait que le message du thread principal doit s'afficher le dernier..

voilà le code de la classe MyThread :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class MyThread extends Thread { private int i; public MyThread(int i) { this.i = i; } @Override public void run() { System.out.println("je suis thread " + i); } }
le code de la classe principale :
Code:

1 2 3 4 5 6 7 8 9 public class Test { public static void main() { for (int i=0; i<5; i++) { Thread thread = new MyThread(i); thread.start(); } System.out.println("et enfin moi"); } }
Le problème que je ne peux pas utiliser les méthodes wait() et notify() pour assurer le fonctionnement souhaité, du fait qu'un thread ne peut pas "notifier" son père..

Merci d'avance pour vos idées..

09/09/2008, 09h04
Invité

Salut,
Est-ce que la méthode Thread.join pourrait répondre à tes attentes ?
Tschau
09/09/2008, 09h25
Balbuzard
ou alors, tu peux essayer de contourner le problème en faisant incrémenter chacun de tes Threads une variable, et mettre une condition pour l'affichage du dernier message : le fait que la variable en question ait atteint une certaine valeur (qui correspond au nombre de Threads)

Bon, c'est peut-être pas de cette façon-là que tu souhaites résoudre ton problème...

EDIT: peut-être une autre façon de faire :
Code:

1 2 3 4 5 6 7 8 for(int i=0; i<nbreThread; i++) { if(thread.getState()=="TERMINATED") { condition++; } } if(condition==nbreThread) { System.out.println(dernierMessage); }

Tu peux utiliser un CountDownLatch :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
class MyThread extends Thread {
	private CountDownLatch countdown;
	private int i;
 
	public MyThread(int i, CountDownLatch countdown) {
		this.i = i;
		this.countdown = countdown;
	}
 
	@Override
	public void run() {
		System.out.println("je suis thread " + i);
		countdown.countDown();
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public class Test {
	public static void main() {
		CountDownLatch countdown = new CountDownLatch(5);
		for (int i=0; i<5; i++) {
			Thread thread = new MyThread(i, countdown);
			thread.start();
		}
		countdown.await();
		System.out.println("et enfin moi");
	}
}

Salut,

Balbuzard > Ta solution n'est pas bonne car il faut synchronisé tout cela ;)

Sinon une autre solution serait d'utiliser les Executors de Java 5 :

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
class MyTask implements Callable<Integer> {
    private int i;
 
    public MyTask(int i) {
        this.i = i;
    }
 
    @Override
    public Integer call() throws Exception {
    	System.out.println("je suis thread " + i);
    	return i;
    }
}
 
public class Test {
    public static void main() throws Exception {
    	// On crée une liste de tâche :
    	List<MyTask> tasks = new ArrayList<MyTask>();
        for (int i=0; i<5; i++) {
        	tasks.add(new MyTask(i));
        }
        // On crée un ExecutorService qui executera au plus 2 tâche à la fois :
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // On lance l'exécution de toutes les tâches (et on attend qu'elles soient finies)
        List<Future<Integer>> results = executor.invokeAll(tasks);
        System.out.println("et enfin moi");
    }
}

a++

09/09/2008, 10h07
Chatbour

Re,

merci beaucoup pour vos réponses :)

je vais adopter une des solutions de adiGuba ou de verbose..

George7 -> la raison que je n'ai pas utilisé la méthode join() c'est parce qu'en l'utilisant je vais perdre le parallélisme car tous les thread vont s'exécuter séquentiellement..

Bonne journée..

Citation:

Envoyé par adiGuba

...
Sinon une autre solution serait d'utiliser les Executors de Java 5 :

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
class MyTask implements Callable<Integer> {
    private int i;
 
    public MyTask(int i) {
        this.i = i;
    }
 
    @Override
    public Integer call() throws Exception {
        System.out.println("je suis thread " + i);
        return i;
    }
}
 
public class Test {
    public static void main() throws Exception {
        // On crée une liste de tâche :
        List<MyTask> tasks = new ArrayList<MyTask>();
        for (int i=0; i<5; i++) {
            tasks.add(new MyTask(i));
        }
        // On crée un ExecutorService qui executera au plus 2 tâche à la fois :
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // On lance l'exécution de toutes les tâches (et on attend qu'elles soient finies)
        List<Future<Integer>> results = executor.invokeAll(tasks);
        System.out.println("et enfin moi");
    }
}

a++

J'ai testé ton code (merci en passant, je ne connaissait pas ExecutorService and Cie) et à l'exécution, voici ce qu'il renvoie

Code:

1
2
3
4
5
6
7
 
je suis thread 1
je suis thread 2
je suis thread 3
je suis thread 4
je suis thread 0
et enfin moi

Je suis surpris par l'ordre, je m'attendais à

Code:

1
2
3
4
5
6
7
 
je suis thread 0
je suis thread 1
je suis thread 2
je suis thread 3
je suis thread 4
et enfin moi

Ça vient de quoi ?

09/09/2008, 10h30
Chatbour

adiGuba -> j'ai essayé ta solution, ça marche nickel mais je remarque que le programme reste bloqué à la fin et ne rend pas la main :?

Citation:

Envoyé par Chatbour

George7 -> la raison que je n'ai pas utilisé la méthode join() c'est parce qu'en l'utilisant je vais perdre le parallélisme car tous les thread vont s'exécuter séquentiellement..

join() est bien une solution valable, mais il faut bien sûr les effectuer après avoir lancé tous les threads. Il faut donc faire une liste de thread :
Code:

1 2 3 4 5 6 7 8 9 10 List<Thread> threads = new ArrayList<Thread>(); for (int i=0; i<5; i++) { Thread thread = new MyThread(i); thread.start(); threads.add(thread); } for (Thread thread : threads) { thread.join(); } System.out.println("et enfin moi");
Citation:

Envoyé par OButterlin

Je suis surpris par l'ordre

Les threads sont exécutés en parallèle : tu ne peux pas déterminer de façons sûr l'ordre exact dans lequel ils s'exécuteront...

Citation:

Envoyé par Chatbour

adiGuba -> j'ai essayé ta solution, ça marche nickel mais je remarque que le programme reste bloqué à la fin et ne rend pas la main :?

Oui j'ai oublié un petit détail : après la fin de tous les traitements, les exécutors conservent les threads endormis afin de pouvoir les réutiliser par la suite, afin de pouvoir les réutiliser sans avoir à recréer un nouveau thread auprès du système.

Donc comme il y a toujours des threads "vivants" ton programme ne s'arrête pas.

Il y a deux solutions :
Spécifier une ThreadFactory pour utiliser des threads daemon :
Code:

1 2 3 4 5 6 7 8 ExecutorService executor = Executors.newFixedThreadPool(2, new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); thread.setDaemon(true); return thread; } });
Les threads daemon ne sont pas compter dans la liste des threads "vivants". C'est à dire que lorsqu'il ne reste que des threads daemon en vie, ils seront stoppé et le programme s'arrêtera...
Arrêter l'executor, ce qui tuera tous les threads une fois que les actions en cours seront terminées (dans le cas où on aurait utiliser submit()). Il suffit pour cela d'appeler la méthode shutdown() après avoir exécuté nos tâches :

Code:

executor.shutdown();

Note : on ne pourra plus utilisé l'exécutor par la suite...
a++

09/09/2008, 14h29
Chatbour

Merci bien adiGuba pour toutes ces explications :ccool: