`` `Python
Importer trådning
Import tid
Klasse ReaderwriterLock:
"" "
En skærmløsning til læser-forfatterproblemet.
Attributter:
Read_count (int):Antal læsere, der i øjeblikket får adgang til ressourcen.
Skriv_count (int):Antal forfattere har i øjeblikket adgang til ressourcen.
Readers_waiting (liste):Liste over læsere, der venter på at få adgang til ressourcen.
Writers_Waiting (liste):Liste over forfattere, der venter på at få adgang til ressourcen.
LOCK (Threading.Lock):En lås til beskyttelse af det kritiske afsnit.
"" "
def __init __ (self):
selv.read_count =0
self.write_count =0
selv.Readers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
def Acquire_read (self):
"" "
Erhverver en læselås.
"" "
med self.lock:
Mens selv.write_count> 0 eller self.writers_waiting:
selv.readers_waiting.append (Threading.Current_Thread ())
self.lock.release ()
Threading.current_thread (). Vent ()
self.lock.acquire ()
selv.read_count +=1
DEF Release_read (self):
"" "
Frigiver en læselås.
"" "
med self.lock:
selv.read_count -=1
Hvis selv.read_count ==0 og self.writers_waiting:
forfatter =self.writers_waiting.pop (0)
forfatter.notify ()
def Acquire_write (self):
"" "
Erhverver en skrivelås.
"" "
med self.lock:
Mens selv.read_count> 0 eller self.write_count> 0 eller self.writers_waiting:
self.writers_waiting.append (threading.current_thread ())
self.lock.release ()
Threading.current_thread (). Vent ()
self.lock.acquire ()
self.write_count +=1
def udgivelse_write (self):
"" "
Frigiver en skrivelås.
"" "
med self.lock:
selv.write_count -=1
Hvis selv.Readers_waiting:
læser =self.readers_waiting.pop (0)
læser.notificer ()
Klasselæser (Threading.Thread):
"" "
En læsertråd.
"" "
def __init __ (selv, lås):
super () .__ init __ ()
self.lock =lås
def run (self):
For _ inden for rækkevidde (5):
self.lock.acquire_read ()
Print (f "Reader {self.name} læser")
Tid.sleep (0.5)
self.lock.release_read ()
print (f "læser {self.name} færdig læsning")
Klasseforfatter (Threading.Thread):
"" "
En forfattertråd.
"" "
def __init __ (selv, lås):
super () .__ init __ ()
self.lock =lås
def run (self):
For _ inden for rækkevidde (5):
self.lock.acquire_write ()
print (f "forfatter {self.name} skriver")
Tid.sleep (1)
self.lock.release_write ()
print (f "forfatter {self.name} færdig skrivning")
Hvis __name__ =="__main__":
LOCK =ReaderWriterLock ()
læsere =[læser (lås) for _ inden for rækkevidde (3)]
Forfattere =[forfatter (lås) for _ inden for rækkevidde (2)]
For læser i læsere:
læser.start ()
For forfatter i forfattere:
forfatter.start ()
For læser i læsere:
Reader.join ()
For forfatter i forfattere:
forfatter.join ()
`` `
Forklaring:
1. `ReaderwriterLock` Klasse:
- `read_count`,` WRITE_COUNT ':Sporer antallet af aktive læsere og forfattere.
- `Readers_Waiting ',' Writers_Waiting ':Lister til at holde tråde, der venter på adgang.
- `Lock`:En mutex til beskyttelse af det kritiske afsnit, hvor tællere og lister ændres.
2. `Acquire_read`:
- Erhverver en læse lås:
- Det kontrollerer først, om nogen forfattere i øjeblikket får adgang til eller venter. I så fald føjes læseren til listen over "Readers_Waiting" og venter.
- Når betingelsen er opfyldt, øges læserens 'read_count', hvilket betyder, at dens indrejse.
3. `udgivelse_read`:
- frigiver en læselås:
- Redlemmer `read_count '.
- Hvis ikke flere læsere er aktive, og forfattere venter, får den første forfatter i `Writers_Waiting 'besked.
4. `Acquire_Write`:
- Erhverv en skrivelås:
- Det kontrollerer først, om nogen læsere eller forfattere i øjeblikket får adgang til eller venter. I så fald føjes forfatteren til `Writers_Waiting 'og venter.
- Når betingelsen er opfyldt, øges forfatterens 'skrivende_count', hvilket betyder, at dens indrejse.
5. `Release_write`:
- frigiver en skrivelås:
- Redlemmer `WRITE_COUNT '.
- Hvis læserne venter, får den første læser i `Readers_Waiting 'besked.
6. `Reader` og` Writer` Classes:
- Disse klasser repræsenterer læser- og forfattertråde.
- De bruger `Acquire_Read/Acquire_Write` og` Release_Read/Release_Write` metoder til at få adgang til den delte ressource.
hvordan det fungerer:
- Monitoren sikrer eksklusiv adgang til ressourcen for forfattere.
- Læsere får lov til at læse samtidigt, men ingen læser kan læse, mens en forfatter skriver.
- Ventende tråde styres i køer og underrettes, når ressourcen bliver tilgængelig.
Bemærk:
- Metoden til en tråd () Meddelelse () `en tråd bruges til at vågne op en ventende tråd.
- Denne kode bruger konceptet om en tilstandsvariabel (implicit af `Wait ()` og `underret ()` i dette eksempel) til at håndtere tråd venting og anmeldelse.
