Python-Multithread-Programmierung 5

Mutex-Sperre ist der einfachste Thread-Synchronisationsmechanismus. Das von Python bereitgestellte Condition-Objekt bietet Unterstützung für komplexe Thread-Synchronisationsprobleme. Bedingung wird als Bedingungsvariable bezeichnet. Zusätzlich zur Bereitstellung von Erfassungs- und Freigabemethoden wie Lock bietet sie auch Warte- und Benachrichtigungsmethoden. Der Thread erfasst zunächst eine Bedingungsvariable und bestimmt dann einige Bedingungen. Wenn die Bedingung nicht erfüllt ist, führen Sie eine Verarbeitung durch, um die Bedingung zu ändern, und benachrichtigen Sie andere Threads über die Benachrichtigungsmethode. Andere Threads im Wartezustand beurteilen die Bedingung erneut, nachdem sie die Benachrichtigung erhalten haben. Dieser Vorgang wird kontinuierlich wiederholt, um komplexe Synchronisationsprobleme zu lösen.

Man kann davon ausgehen, dass das Condition-Objekt eine Sperre (Lock/RLock) und einen Wartepool verwaltet. Der Thread erhält das Condition-Objekt durch Acquire. Wenn die Wartemethode aufgerufen wird, gibt der Thread die Sperre innerhalb der Bedingung auf und wechselt in den blockierten Zustand. Gleichzeitig wird der Thread im Wartepool aufgezeichnet. Wenn die Notify-Methode aufgerufen wird, wählt das Condition-Objekt einen Thread aus dem Wartepool aus und weist ihn an, die Acquire-Methode aufzurufen, um zu versuchen, die Sperre zu erhalten.

Der Konstruktor des Condition-Objekts kann ein Lock/RLock-Objekt als Parameter akzeptieren. Wenn nicht angegeben, erstellt das Condition-Objekt intern ein RLock.

Zusätzlich zur Notify-Methode stellt das Condition-Objekt auch die NotifyAll-Methode bereit, mit der alle Threads im Wartepool benachrichtigt werden können, damit sie versuchen, die interne Sperre zu erhalten. Aufgrund des oben genannten Mechanismus können Threads im Wartezustand nur über die Benachrichtigungsmethode geweckt werden. Die Funktion von notifyAll besteht also darin, zu verhindern, dass Threads für immer in einem stillen Zustand bleiben.

Das klassische Problem, das die Synchronisierung von Bedingungsvariablen demonstriert, ist das Produzenten- und Konsumentenproblem: Angenommen, es gibt eine Gruppe von Produzenten (Produzent) und eine Gruppe von Konsumenten (Konsumer), die über einen Markt mit Produkten interagieren. Die „Strategie“ des Herstellers besteht darin, 100 Produkte zu produzieren und auf den Markt zu bringen, wenn weniger als 1.000 Produkte auf dem Markt sind, während die „Strategie“ des Verbrauchers darin besteht, mehr als 100 Produkte auf dem Markt zu konsumieren. Der Code zur Verwendung von Condition zur Lösung des Problems von Produzenten und Verbrauchern lautet wie folgt:

import threading
import time
  
class Producer(threading.Thread):
    def run(self):
        global count
        while True:
            if con.acquire():
                if count > 1000:
                    con.wait()
                else:
                    count = count+100
                    msg = self.name+' produce 100, count=' + str(count)
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)
  
class Consumer(threading.Thread):
    def run(self):
        global count
        while True:
            if con.acquire():
                if count < 100:
                    con.wait()
                else:
                    count = count-3
                    msg = self.name+&#39; consume 3, count=&#39;+str(count)
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)
  
count = 500
con = threading.Condition()
  
def test():
    for i in range(2):
        p = Producer()
        p.start()
    for i in range(5):
        c = Consumer()
        c.start()
if __name__ == &#39;__main__&#39;:
    test()