L'envoi de messages entre la classe threads Python

Quelqu'un sait comment je peux envoyer une variable (ou une variable) à partir de threadOne à threadTwo dans ce code, sans l'aide d'une variable globale? Si non, comment pourrais-je faire fonctionner une variable globale? Il suffit de définir avant les deux classes et utiliser la définition globale de la fonction d'exécution?

import threading

print "Press Escape to Quit"

class threadOne(threading.Thread): #I don't understand this or the next line
    def run(self):
        setup()

    def setup():
        print 'hello world - this is threadOne'


class threadTwo(threading.Thread):
    def run(self):
        print 'ran'

threadOne().start()
threadTwo().start()

Grâce

OriginalL'auteur Sam Heather | 2013-01-24

  1. 17

    Vous pouvez utiliser les files d'attente pour envoyer des messages entre les threads dans un thread de façon sécuritaire.

    def worker():
    while True:
        item = q.get()
        do_work(item)
        q.task_done()

q = Queue()
for i in range(num_worker_threads):
     t = Thread(target=worker)
     t.daemon = True
     t.start()

for item in source():
    q.put(item)

q.join()       # block until all tasks are done
    Puis-je définir en dehors de la Classe?
    Vous devez créer la File d'attente avant de commencer à les utiliser, donc oui, en dehors de/avant le thread de Classes.

    OriginalL'auteur Gerald Kaszuba

  2. 4

    Ici, vous allez, à l'aide de Lock.

    import threading

print "Press Escape to Quit"

# Global variable
data = None

class threadOne(threading.Thread): #I don't understand this or the next line
    def run(self):
        self.setup()

    def setup(self):
        global data
        print 'hello world - this is threadOne'

        with lock:
            print "Thread one has lock"
            data = "Some value"


class threadTwo(threading.Thread):
    def run(self):
        global data
        print 'ran'
        print "Waiting"

        with lock:
            print "Thread two has lock"
            print data

lock = threading.Lock()

threadOne().start()
threadTwo().start()

    En utilisant la variable globale data.

    Le premier thread acquiert le verrou et d'écriture de la variable.

    Deuxième thread attend de données et l'imprime.

    Mise à jour

    Si vous avez plus de deux threads qui ont besoin de messages à être passé autour, il est préférable d'utiliser threading.Condition.

    Il est presque toujours préférable d'utiliser une file d'attente plutôt qu'une variable globale avec une serrure à envoyer des données à partir d'un thread à l'autre. Vous devriez commencer avec une file d'attente, sauf si il y a une bonne raison pas pour utiliser un. Voir la réponse ci-dessous à partir de Gerald Kaszuba
    Pouvez-vous expliquer pourquoi?
    Je serais intéressé de savoir pourquoi.
    ..parce que la serrure ne doit être prise pour le temps pris pour pousser un objet de référence sur la file d'attente, (et pop hors de nouveau). Il n'est pas nécessaire de garder toute serrure alors qu'un producteur est en cours de chargement dans les données ou si un producteur est en cours de traitement.
    Les files d'attente automatiquement prendre soin de verrouillage pour vous. La manipulation de code de verrouillage vous-même ajoute une surcharge inutile à votre code (et de l'entretien/le débogage des cauchemars).

    OriginalL'auteur ATOzTOA