Thread et execution unique

Bonjour a tous,
j'ai une petite question pour vous.

Je souhaite multiThreader un traitement, ou plutôt effectué le même traitement par N Thread (suivant le processeur sur lequel le soft est lancé).

Donc, j'ai implementé tout mon petit monde, jusque la pas de probleme.

Mon probleme est que je n'arrive pas a restreindre l'exécution d'une methode a la premiere thread qui a terminé le traitement. J'ai essayé via des methode sychronisé couplé a un boolean static, mais cela ne fonctionne pas ...

voici mon code:

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
public class AleatoireMultiThread extends Aleatoire implements Runnable{
 
	public static boolean resolu;
 
	public AleatoireMultiThread(int taille, Gestion g, boolean methode) {
		super(taille, g, methode);
		resolu=false;
	}
 
	public void run(){
		//on lance la resolution
		if(this.methode)
			resolutionSemiAleat(); 
		else
			resolutionFullAleat();
 
		if(!resolu){
			finalise();
 
		}
	}
 
	/**
         * Fonction qui permet de faire arrete le travail des Thread
         */
	public synchronized void setResolu(){
		resolu=true;
	}
 
	/**
         * Fonction permet d'afficher le resultat du thread qui fini en premier sa resolution
         */
	private synchronized void finalise(){		
 
		if(!resolu){
		//different traitement 
               ...................
 
		//arrete les autres thread
		setResolu();
		}
	}
 
	/**
         * Fonction qui effectue la resolution de maniere semi-aleatoire
         * c'est a dire que la pose du polyominos test toutes les variantes possible
         * afin d'augmente les chances de pouvoir pose le polyominos
         */
	private void resolutionSemiAleat(){
		Plateau tmp=new Plateau(plat);
 
		//tant que le score du plateau n'est pas egal au score maximal
		while(tmp.getScore()!=tmp.scoreOptimal && !resolu ){
 
			//traitement
		}
 
		//on a trouve une solution
		plat=new Plateau(tmp);
	}
 
	/**
         * Fonction qui effectue la resolution de maniere aleatoire
         */
	private void resolutionFullAleat(){
		Plateau tmp=new Plateau(plat);
 
		//tant que le score du plateau n'est pas egal au score maximal
		while(tmp.getScore()!=tmp.scoreOptimal  && !resolu){
 
			//traitement
		}
 
		//on a trouve une solution
		plat=new Plateau(tmp);
	}
}

et voici le code qui genere les thread de traitement:

Code:

1
2
3
4
5
6
7
8
9
 
Thread[] tabThread=new Thread[nbThread];
					for(int i=0;i<nbThread;i++){
						Thread t=new Thread(new AleatoireMultiThread(getTaille(),g,true),"Thread "+i);
						tabThread[i]=t;
					}
 
					for(Thread t: tabThread)
						t.start();

Avez vous une idée pour que ma methode finalise soit executer une seul fois ?

Je vous remercie d'avance pour votre aide ;)