Discussion :

[Chatbour]

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 :

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

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 :

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

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

[Invité]

Salut,
Est-ce que la méthode Thread.join pourrait répondre à tes attentes ?
Tschau

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

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

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

[verbose]

Tu peux utiliser un CountDownLatch :

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

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

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

[adiGuba]

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 :

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

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

[OButterlin]

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

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

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

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 :

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

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 ?

[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

[adiGuba]

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 :

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

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");

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

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 :

1. Spécifier une ThreadFactory pour utiliser des threads daemon :
   

   Code :

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

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

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

   executor.shutdown();

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

a++

[Chatbour]

Merci bien adiGuba pour toutes ces explications