`` `Python
Threading importieren
Importzeit
Klassenreaderwriterlock:
"" "
Eine Monitorlösung für das Problem der Leser-Autoren.
Attribute:
Read_Count (int):Anzahl der Leser, die derzeit auf die Ressource zugreifen.
Write_Count (int):Anzahl der Autoren, die derzeit auf die Ressource zugreifen.
Readers_waiting (Liste):Liste der Leser, die darauf warten, auf die Ressource zuzugreifen.
Writers_waiting (Liste):Liste der Autoren, die darauf warten, auf die Ressource zuzugreifen.
Lock (Threading.lock):Ein Schloss zum Schutz des kritischen Abschnitts.
"" "
def __init __ (selbst):
self.read_count =0
self.write_count =0
self.Readers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
Def Acquire_Read (Selbst):
"" "
Erwirbt ein Leseschloss.
"" "
mit self.lock:
während self.write_count> 0 oder self.writers_waiting:
self.readers_waiting.append (Threading.current_thread ())
self.lock.release ()
threading.current_thread (). warte ())
self.lock.acquire ()
self.read_count +=1
Def Release_Read (Selbst):
"" "
Veröffentlicht ein Leseschloss.
"" "
mit self.lock:
self.read_count -=1
Wenn self.read_count ==0 und self.writers_waiting:
writer =self.writers_waiting.pop (0)
writer.notify ()
Def Acquire_Write (Selbst):
"" "
Erwirbt ein Schreibschloss.
"" "
mit self.lock:
während self.read_count> 0 oder self.write_count> 0 oder self.writers_waiting:
self.writers_waiting.append (threading.current_thread ())
self.lock.release ()
threading.current_thread (). warte ())
self.lock.acquire ()
self.write_count +=1
Def Release_Write (Selbst):
"" "
Veröffentlicht ein Schreibschloss.
"" "
mit self.lock:
self.write_count -=1
Wenn self.readers_waiting:
reader =self.readers_waiting.pop (0)
reader.notify ()
Klassenleser (Threading.Thread):
"" "
Ein Leser -Thread.
"" "
Def __init __ (Selbst, Schloss):
Super () .__ init __ ()
self.lock =lock
def run (self):
für _ im Bereich (5):
self.lock.acquire_read ()
print (f "reader {self.name} liest")
time.sleep (0,5)
self.lock.release_read ()
print (f "reader {self.name} fertig gelesen")
Klassenschreiber (Threading.Thread):
"" "
Ein Schriftsteller -Thread.
"" "
Def __init __ (Selbst, Schloss):
Super () .__ init __ ()
self.lock =lock
def run (self):
für _ im Bereich (5):
self.lock.acquire_write ()
print (f "writer {self.name} schreibt")
time.sleep (1)
self.lock.release_write ()
print (f "Schriftsteller {self.name} fertig mit dem Schreiben"))
Wenn __name__ =="__main__":
lock =readerWriterLock ()
Readers =[Leser (Sperre) für _ in Bereich (3)]
Writers =[Writer (Lock) für _ in Bereich (2)]
Für Leser in den Lesern:
reader.start ()
Für Schriftsteller in Schriftstellern:
writer.start ()
Für Leser in den Lesern:
reader.join ()
Für Schriftsteller in Schriftstellern:
writer.join ()
`` `
Erläuterung:
1. `readerWriterLock` Klasse:
- `read_count`,` write_count`:verfolgt die Anzahl der aktiven Leser und Autoren.
- `readers_waiting`,` writers_waiting`:listet auf, um Threads auf den Zugriff zu halten.
- `lock`:Ein Mutex zum Schutz des kritischen Abschnitts, in dem Zähler und Listen geändert werden.
2. `accoire_read`:
- erwirbt ein Leseschloss:
- Es wird zunächst überprüft, ob Autoren derzeit zugreifen oder warten. In diesem Fall wird der Leser zur Liste `readers_waiting` hinzugefügt und wartet.
- Sobald die Bedingung erfüllt ist, wird der Leser "Read_Count" inkrementiert, was seinen Eintrag bedeutet.
3. `release_read`:
- veröffentlicht ein Leseschloss:
- Verringungen das `read_count`.
- Wenn keine Leser mehr aktiv sind und Schriftsteller warten, wird der erste Schriftsteller in `writers_waiting` benachrichtigt.
4. `accoire_write`:
- erwirbt ein Schreibschloss:
- Es wird zunächst überprüft, ob Leser oder Autoren derzeit zugreifen oder warten. Wenn ja, wird der Schriftsteller zu `writers_waiting` hinzugefügt und wartet.
- Sobald die Bedingung erfüllt ist, wird der Schriftsteller "write_count" inkrementiert, was seinen Eintrag bedeutet.
5. `release_write`:
- veröffentlicht ein Schreibschloss:
- Dekrementiert das `write_count`.
- Wenn die Leser warten, wird der erste Leser in `readers_waiting` benachrichtigt.
6. `reader` und` writer` klassen:
- Diese Klassen repräsentieren Leser- und Schriftsteller -Threads.
- Sie verwenden die Methoden "Accurire_read/Accire_Write" und `Release_Read/Release_Write`, um auf die freigegebene Ressource zuzugreifen.
wie es funktioniert:
- Der Monitor gewährleistet den exklusiven Zugriff auf die Ressource für Schriftsteller.
- Die Leser dürfen gleichzeitig lesen, aber kein Leser kann lesen, während ein Schriftsteller schreibt.
- Wartefäden werden in Warteschlangen verwaltet und benachrichtigt, wenn die Ressource verfügbar ist.
Hinweis:
- Die Methode "notify ()` eines Threads wird verwendet, um einen wartenden Thread aufzuwecken.
- Dieser Code verwendet das Konzept einer Zustandsvariablen (impliziert von `wait ()` und `notify ()` in diesem Beispiel), um das Warten und Benachrichtigungen von Thread zu verarbeiten.
