Discussion :

[cyclopsnet]

Bonjour,

J'ai quelques questions par rapport aux Thread :

1)J'ai une méthode où je lance un thread, ma question est la suivante , est ce que je sort de cette fonction dès que le thread est lancé ou elle attend que le thread se termine.
2) comment faire pour que dès que je lance le thread je sorts de ma fonction (J'attends pas que le thread termine son travail).

3) comment recuperer un retour d'une fonction qui est dans une classe thread?

Merci de m'aider sur ce point.

[tchize_]

1) ben elle continue, elle attends pas, sinon il n'y aurais aucun intérêt à utiliser des thread
2) voir 1)
3) peux-tu détailler, je comprend pas la question la

[wax78]

3) comment recuperer un retour d'une fonction qui est dans une classe thread?

Je suppose que tu vx dire, recuperer une (ou des valeurs) calculées par le thread une fois que celui ci a terminé.

Tu px utiliser un simple truc ainsi :

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
public leThread extends Thread
{
	String resultat;
	public void run ()
	{
		// Le code de calcul ou autres
		// Mets le resulatt dans la variable.
		resultat ="Super";
	}
 
	public synchronized String getResultat()
	{
		return resultat;
	}	
}

[cyclopsnet]

Merci

[adiGuba]

Salut,

@wax78 :

Le synchronized est inutile ici puisqu'il n'y a qu'une simple affectation. De plus il n'y a pas de synchronization dans le code du run() donc c'est d'autant plus inutile. Par contre il serait souhaitable de déclarer l'attribut "resultat" en volatile, afin d'éviter des optimisations hasardeuses...



A noter qu'avec Java 5.0 on peut tout simplement utiliser les Callable<T>/Future<T> :

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
    public static Future<String> method() {
        /*
         * On crée un objet FutureTask, qui représente notre tâche via un Callable.
         * Ce dernier à l'avantage de proposer un type de retour paramétrable,
         * et de renvoyer des exceptions :D
         */
        FutureTask<String> task = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // On simule un traitement :
                Thread.sleep(5000);
                return "Super";
            }
        });
 
        /*
         * On lance un thread associé à cette tâche.
         */
        new Thread(task, "MyThread").start();
 
        /*
         * On retourne la tâche en tant qu'objet "Future".
         * Cela nous permettra :
         *     - D'interrompre la tâche : cancel(true)
         *  - De connaitre son état : isDone() / isCancelled()
         *  - De récupérer le resultat : get()
         */
        return task;
    }

a++

[wax78]

Pour le synchronized je n'ai qu'une seule chose a dire pour ma défence :

Merci eclipse (generate getters/setters avec le case a decocher synchronized, voila ce qui arrive qd on va trop vite)