thread et return

Version imprimable

thread et return

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

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

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

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

Code:

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:

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:

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

26/05/2007, 01h43
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()
26/05/2007, 08h28
CyberChouan
Citation:

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!

Citation:

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:

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

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:

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:

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:

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

26/05/2007, 10h03
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.
26/05/2007, 11h50
CyberChouan

Citation:

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!

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

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

26/05/2007, 14h48
CyberChouan
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:

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

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

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

26/05/2007, 16h59
CyberChouan

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...
27/05/2007, 00h44
ulysse031

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
27/05/2007, 09h17
guigui5931

Citation:

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

:cry:

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.
29/05/2007, 16h48
ulysse031

Merci J'ai Bien Compris Les Thread
31/05/2007, 09h06
gk14fire

Citation:

Envoyé par ulysse031

Merci J'ai Bien Compris Les Thread

C'est à se demander...