threading python: event.set () notifiera vraiment chaque thread en attente

Si j'ai un filetage.L'événement et les deux lignes de code suivantes...

event.set()
event.clear()

...et j'ai des fils qui sont en attente pour cet événement.

Ma question est liée à ce qui se passe lors de l'appel de la méthode set ():

  • Puis-je être sûr que tout le thread en attente(s) sera notifiée? (c'est à dire de l'Événement.set() "informe" le fils)
  • Ou peut-il arriver que ces deux lignes sont exécutées rapidement les uns après les autres, que certains sujets peut-être encore en attente? (c'est à dire de l'Événement.wait() sondages de l'événement de l'état, qui peut déjà être "effacé" de nouveau)

Merci pour vos réponses!

source d'informationauteur Criss

  1. 12

    Il est assez facile de vérifier que les choses fonctionnent comme prévu:

    import threading

e = threading.Event()
threads = []

def runner():
    tname = threading.current_thread().name
    print 'Thread waiting for event: %s' % tname
    e.wait()
    print 'Thread got event: %s' % tname

for t in range(100):
    t = threading.Thread(target=runner)
    threads.append(t)
    t.start()

raw_input('Press enter to set and clear the event:')
e.set()
e.clear()
for t in threads:
    t.join()
print 'All done.'

    Si vous exécutez le script ci-dessus, et il se termine, tout doit être bien 🙂 à noter qu'une centaine de threads sont en attente pour l'événement à définir; il est défini et effacé tout de suite; tous les fils doivent voir cela, et devrait se terminer (mais pas dans un ordre déterminé, et le "Tout fait" peut être imprimé partout après le "Appuyez sur enter" de l'invite, non seulement à la toute fin.

  2. 10

    Dans les entrailles de Python, un événement est mis en œuvre avec un Condition() objet.

    Lors de l'appel de la event.set() méthode, la notify_all() de la condition est appelée (après l'obtention de la serrure pour être sûr de ne pas être interrompu), puis tous les threads de recevoir la notification (le verrou est libéré que lorsque tous les threads sont avertis), de sorte que vous pouvez être sûr que tous les threads seront effectivement notifié.

    Maintenant, la compensation de la manifestation juste après la notification n'est pas un problème.... jusqu'à ce que vous ne voulez pas vérifier la valeur de l'événement dans les threads en attente avec un event.is_set()mais vous avez seulement besoin de cette sorte de vérifier si vous avez été en attente avec un délai d'attente.

    Exemples :

    pseudo-code qui fonctionne : 

    #in main thread
event = Event()
thread1(event)
thread2(event)
...
event.set()
event.clear()

#in thread code
...
event.wait()
#do the stuff

    pseudo-code qui ne fonctionne pas : 

    #in main thread
event = Event()
thread1(event)
thread2(event)
...
event.set()
event.clear()

#in thread code
...
while not event.is_set():
   event.wait(timeout_value)
#do the stuff

    Édité : en python >= 2.7 vous pouvez toujours attendre pour un événement avec un délai d'attente et être sûr de l'état de l'événement :

    event_state = event.wait(timeout)
while not event_state:
    event_state = event.wait(timeout)