Discussion :

[l1nux]

Bonjour, j'aimerais récupérer la variable d'un thread. J'ai essayé comme ça mais ça me retourne 'none' et non le message. si quelqu’un peut m'expliquer svp

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
 
import threading
 
class app:
 
    def __init__(self):
        self.var = myThread().start()
 
    def message(self):
        print(self.var)
 
class myThread(threading.Thread):
 
    def __init__(self):
        threading.Thread.__init__(self)
        self.var = 'un message'
 
    def run(self):
        self.var += ' et de 2 !'
 
    def stop(self):
        return self.var
 
app().message()

[wiztricks]

Salut,

Si je fabrique une classe A dont les instances ont un attribut toto:

Code :

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

1
2
3
4
5
>>> class A:
...     def __init__(self, toto):
...         self.toto = toto
...
>>>

pour accéder au toto d'une instance, j'écris:

Code :

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

1
2
3
4
>>> a = A('tutu')
>>> a.toto
'tutu'
>>>

Les threads n'ajoutent rien à ces bases là (excepté des questions sur l'atomicité de l'accès à l'objet associé à la variable/attribut).

- W

[l1nux]

Merci pour votre réponce rapide
J'ai donc essayé le code suivant mais je retrouve en sortie ce que j'ai entré. De plus j'ai l'impression que myThread s’exécute en tant que class et non en tant que thread.

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
 
import threading
 
class app:
 
    def __init__(self):
        pass
 
    def message(self):
        th = myThread('hey')
        print(th.var)
 
class myThread(threading.Thread):
 
    def __init__(self, var):
        threading.Thread.__init__(self)
        self.var = var
 
    def run(self):
        self.var = 'un message'
 
app().message()

[wiztricks]

Salut,

J'ai donc essayé le code suivant mais je retrouve en sortie ce que j'ai entré.

L'attribut "var" est initialisé à la création de l'instance et est modifié par la méthode "run". Si, lorsqu'on récupère "var", on récupère la valeur initiale, c'est que "run" n'a pas été exécuté. Puis je cherche à comprendre pourquoi.

De plus j'ai l'impression que myThread s’exécute en tant que class et non en tant que thread.

Et moi j'ai l'impression que vous avez survolé un peu trop vite les classes avec Python et si vous ne comprenez pas les quelques lignes de code que vous écrivez, il va peut être falloir vous y (re)plonger (et en plus il y a des exercices corrigés).

- W

[l1nux]

Merci beaucoup, je suis aller voir la doc et ça fonctionne.
Juste en bonnus : pour attendre que la réponce soit faite est-ce que comme j'ai fait c'est ''propre'' ?
Sinon résolu, merci.

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
 
import threading, time
 
class app:
 
    def __init__(self):
        self.th = myThread()
        self.th.start()
 
    def message(self):
        while self.th.var == '':
            pass
        print(self.th.var)
 
class myThread(threading.Thread):
 
    def __init__(self):
        threading.Thread.__init__(self)
        self.var = ''
 
    def run(self):
        time.sleep(5)
        self.var = 'un message'
 
app().message()

[wiztricks]

Salut,

Juste en bonnus : pour attendre que la réponce soit faite est-ce que comme j'ai fait c'est ''propre'' ?

Si on crée des threads, c'est pour avoir des activités asynchrones: on ne sait pas quand l'information produite par un thread sera disponible.

Si l'autre thread fait une attente "active" (avec une boucle comme vous l'avez fait), autant faire le boulot directement dans le même thread car le CPU utilisé dans l'attente active, c'est moins de CPU pour que le thread fasse rapidement son boulot (parce que le Global Interlock).

Si on attend que le thread se termine, la méthode .join est plus adaptée.

Dans la documentation du module threading, on vous parle d'Event, et de Queue, objets qui permettent d'attendre sans consommer de CPU.

- W