Discussion :

[ulysse031]

salut j'ai un probleme avec mon code ,je voulais bien qu'il fonctionne car je ne sais pas comment arranger mes threads

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
30
31
 
salut 
je voulais bien utiliser les threads
de cette façons 
 
class thread
{
public static ArrayList methode() {
 
 
thread1 qui fait ArrayList A = calcule1.methode();
thread2 qui fait ArrayList B=calcule.methode();
les deux thread exicute en paralle 
puis 
thread3 qui fait 
while (thread1 !=null &&)
{
try {
this.sleep(100);
}
catch (Exception G) {}
}
}
ArrayList C =new Arraylist();
C.add(A);
C.add(B);
 
 
return(c)
}
}

merci de bien m'aider

[CyberChouan]

1) Ton mélange de code et de texte est très peu clair...

2) Pourquoi veux-tu absolument utiliser des threads séparés pour tes calculs?

Sinon, pour répondre à ta question, tu peux utiliser la méthode isAlive() de tes threads, et peut-être également utiliser des threads "synchronisés" pour s'assurer que ton thread 3 démarre après avoir obtenu le résultat des deux autres

[CyberChouan]

Autre idée (potentiellement mauvaise ou améliorable: je ne suis pas expert en Threads)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class MonThreadA extend Thread {
 
   private ArrayList resultat;
   public ArrayList getResultat() { return resultat; }
 
   public void run() {
      // methode de calcul de ton resultat
   }
}

Code :

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

1
2
3
4
5
 
public class MonThreadB extend Thread {
   // Sur le meme modele que MonThreadA avec ta deuxieme methode de
   // calcul dans le run()
}

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
 
public class ClassePrincipale() {
 
   public static void main(String[] args) {
       MonThreadA threadA = new MonThreadA();
       MonThreadB threadB = new MonThreadB();
 
      threadA.start();
      threadB.start();
 
      while(threadA.isAlive() || threadB.isAlive()) {
         // on attend la fin d'exécution des calculs
      }
 
      ArrayList result = new ArrayList();
      result.add(threadA.getResult());
      result.add(threadB.getResult());
   }
}

[ulysse031]

salut merci mais j'ai besoin que ça fonctionne
mais j'ai remarqué que run() de threadMonThreadA etMonThreadB ne contient rien ? et en plus je voulais utiliser return(resultat) de la classe ClassePrincipale()

[CyberChouan]

salut merci mais j'ai besoin que ça fonctionne
mais j'ai remarqué que run() de threadMonThreadA etMonThreadB ne contient rien ?

Effectivement c'est un code partiel! J'ai mis un commentaire dans la méthode: c'est à toi d'écrire le calcul que tu veux faire dans la méthode "run()", qui mettra à jour la variable de classe "resultat". Je ne peux pas deviner quel calcul tu veux faire!

et en plus je voulais utiliser return(resultat) de la classe ClassePrincipale()

Là je ne comprends pas très bien... Une classe ne renvoie rien! Seules les méthodes peuvent renvoyer un resultat.

Et si tu as besoin de récupérer la liste de ta classe principale, tu transforme la méthode main en:

Code :

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

1
2
3
4
5
public ArrayList maMethodePrincipaleDeMaClassePrincipale() {
   // Meme code que celui que je t'ai donné...
   return resultat;
}

Et sinon, si tu veux une liste qui contient non pas les deux listes obtenues par tes calculs mais la liste concaténée de tes deux résultats intermédiaires, il faut remplacer les "add" par des "addAll". Désolé, il était tard quand j'ai écrit ma réponse précédente hier soir

[CyberChouan]

Après un petit test, le code que je t'ai donné fonctionne. Voici 3 classes écrites rapidement. Tu peux les faire tourner pour t'assurer qu'elle font bien ce que tu attends (deux calculs en parallèle dont on attend les résultats avant de poursuivre l'exécution) et t'en inspirer pour résoudre ton problème:

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
 
package thread;
 
public class Test {
 
	public static int calculParallele() {
 
		ThreadA ta = new ThreadA();
		ThreadB tb = new ThreadB();
 
		ta.start();
		tb.start();
 
		while(ta.isAlive() || tb.isAlive()) {
			try {
				// on attend 100ms avant de retester
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// on ne fait rien
			}
		}	
		return ta.getResultat() + tb.getResultat();
	}
 
	public static void main(String[] args) {
		System.out.println(calculParallele());
	}
}

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
 
package thread;
 
public class ThreadA extends Thread {
 
	private int resultat = 0;
 
	public int getResultat() { return resultat; }
 
	public void run() {
		for(int i=0; i<100000; i++) {
			this.resultat++;
		}
	}
}

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
 
package thread;
 
public class ThreadB extends Thread {
 
	private int resultat = 0;
 
	public int getResultat() { return resultat; }
 
	public void run() {
		for(int i=0; i<100; i++) {
			this.resultat++;
			try {
				// on attend 100ms entre chaque itération
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// on ne fait rien
			}
		}
	}
}