Thread dans une fonction

Version imprimable

25/10/2010, 11h28
cyclopsnet

Thread dans une fonction

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.
25/10/2010, 12h34
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

Citation:

Envoyé par cyclopsnet

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:

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

25/10/2010, 16h43
cyclopsnet

Merci

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:

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

25/10/2010, 17h04
wax78

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

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