thread et return

**ulysse031** · 25/05/2007, 22h36

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** · 25/05/2007, 23h26

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** · 25/05/2007, 23h44

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** · 26/05/2007, 01h43

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** · 26/05/2007, 08h28

Envoyé par ulysse031

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!

Envoyé par ulysse031

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** · 26/05/2007, 08h44

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

**Sanguko** · 26/05/2007, 10h03

CyberChouan,

Tu devrais regarder du cote des interfaces java.util.concurrent.Future et java.util.concurrent.Callable. C'est du déjà tout fait !

Cette solution a déjà été proposée ici, mais visiblement ulysse031 est un peu dur de la feuille.

**CyberChouan** · 26/05/2007, 11h50

Envoyé par Sanguko

CyberChouan,

Tu devrais regarder du cote des interfaces java.util.concurrent.Future et java.util.concurrent.Callable. C'est du déjà tout fait !

Cette solution a déjà été proposée ici, mais visiblement ulysse031 est un peu dur de la feuille.

Comme je l'ai dit, je n'ai que très peu utilisé les threads, et j'étais à peu prêt certain qu'il y avait un moyen de faire ça plus proprement qu'avec ma bidouille. Je regarderai ça: comme ça je serai un peu moins ignare la prochaine fois

Merci beaucoup pour l'info!

**ulysse031** · 26/05/2007, 12h12

merci encore mes voila le code qui fonctionne mais je voulais confirmer si c'est just

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
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
79
80
81
82
83
84
85
86
87
 
 
package aa;
 
 
import java.util.ArrayList;
import java.util.Iterator;
 
 
class ThreadA extends Thread {
 
           ArrayList A = new ArrayList ();
          public ArrayList getResultat() {
          A.add("ulysse");
          A.add("ulysse1");
             return (A); 
           }
 
           public void run() {
                    {
 
                      Iterator IT = A.iterator();
                 while (IT.hasNext()) {
                A.add(IT.next());
                                                }
 
                   }
           }
   }
 
   class ThreadB extends Thread {
 
     ArrayList B = new ArrayList ();
     public ArrayList getResultat() {
     B.add("ulysse3");
        return (B); 
      }
 
      public void run() 
               {
 
                 Iterator IT = B.iterator();
            while (IT.hasNext()) {
           B.add(IT.next());
           }
 
 
           }
   }
 
 
public class  thread1 {
 
        public static ArrayList calculParallele() {
                ArrayList C = new ArrayList();
                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
                        }
                }
 
 
                Iterator IT = ta.getResultat().iterator();
 
                                 while (IT.hasNext()) {
                                 C.add(IT.next());
                                     }
 
                                IT = tb.getResultat().iterator();
                                while (IT.hasNext()) {
                                C.add(IT.next());
                                     }
 
                return (C);
        }
 
 
}

j'ai doute avec run() de ThreadA et ThreadB est ce que c'est just

et est ce que les deux threadA et B fonctionne en parallele

merci encore

**CyberChouan** · 26/05/2007, 14h48

OULA!!!

1) Tu devrais aller voir la FAQ au rayon "Conventions de nommage": une variable commence par une minuscule: donc tes iterateurs devraient d'appeler "it" et non "IT"

2) Un code du genre:

Code :

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

1
2
3
4
5
6
7
 
List al = new arrayList();
al.add("toto");
Iterator it = al.iterator();
while(it.hasNext()) {
   al.add(it.next());
}

C'est l'erreur assurée!!! (ConcurrentModificationException): on ne peut pas modifier une liste sur laquelle on est en train d'itérer!

Je pense que tu devrais te replonger un peu dans les bases du langage avant de te lancer dans des problèmes de traitements parallèles avec des threads...

Dans ton cas, ton code va marcher et effectuer tes deux calculs en parallèle. Tu pourras vérifier que ta liste C contient "ulysse1", "ulysse2" et "ulysse3". Mais ça marche uniquement par chance parceque dans ce cas précis, la méthode "hasNext()" de tes threads A et B renvoie toujours "false".

**ulysse031** · 26/05/2007, 15h28

salut merci pour la remarque en plus tu m'as pas bien compris
voila le probleme

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
 
j'ai encore soucis avec chaque thread a et b 
par exemple
class ThreadA extends Thread {   ArrayList A = new ArrayList ();
          public ArrayList getResultat(){
          A.add("ulysse");
          A.add("ulysse1");
             return(A); 
           }
 
           publicvoid run(){
                    {
 
                   je voulais mettre quelque chose dans run mais je ne sais pas quoi je mettre  
                   }
           }
   }
et en plus je voulais rie toucher je garde cette partie 
public ArrayList getResultat(){
          A.add("ulysse");
          A.add("ulysse1");
             return(A); 
           }
modifier just run

**CyberChouan** · 26/05/2007, 16h59

Chacun de tes threads A et B est supposé effectuer un "calcul", qui une fois terminé donne une liste si je me souviens bien de ta problématique initiale.

Et bien dans le "run()" de chacun de tes threads, tu mets justement cette méthode de calcul. Je ne vois pas où est ton problème.

Je suppose de plus que ce calcul doit être long (récursif, ou longue itération): si ta méthode de calcul s'exécute en 0.1s chrono, je ne vois pas l'intérêt de paralléliser tes traitements dans des threads...

**ulysse031** · 27/05/2007, 00h44

bonsoir
est ce que il y a une autre méthodes dans run de mes threads car je ne sais pas quoi mettre dans run de chaque thread a et b j'ai doute avec run de thread a et b

**guigui5931** · 27/05/2007, 09h17

est ce que il y a une autre méthodes dans run de mes threads car je ne sais pas quoi mettre dans run de chaque thread a et b j'ai doute avec run de thread a et b

Comme te l'a dit plusieurs fois CyberChouan tu dois mettre dans run le code du calcul que tu veux executer.
Vu tes réponses je me demande si tu sais ce qu'est un thread. Tu devrais peut être te renseigner sur le notion même.