Importeer threading

importtijd

Class ReaderWriterLock:

"" "

Een monitoroplossing voor het probleem van de lezers-schrijvers.

Attributen:

Read_Count (int):Aantal lezers dat momenteel toegang heeft tot de bron.

Write_Count (int):Aantal schrijvers dat momenteel toegang heeft tot de bron.

Readers_Waiting (lijst):Lijst van lezers die wachten op toegang tot de bron.

Writers_waiting (lijst):lijst met schrijvers die wachten op toegang tot de bron.

Lock (threading.lock):een slot om het kritieke gedeelte te beschermen.

"" "

def __init __ (zelf):

self.read_count =0

self.write_count =0

self.readers_waiting =[]

self.writers_waiting =[]

self.lock =threading.lock ()

def acquire_read (self):

"" "

Verwerft een leesvergrendeling.

"" "

met Self.Lock:

terwijl self.write_count> 0 of self.writers_waiting:

self.readers_waiting.append (threading.current_thread ())

self.lock.Release ()

threading.current_thread (). Wait ()

self.lock.acquire ()

self.read_count +=1

def release_read (self):

"" "

Geeft een leesvergrendeling vrij.

"" "

met Self.Lock:

self.read_count -=1

if self.read_count ==0 en self.writers_waiting:

schrijver =self.writers_waiting.pop (0)

schrijver.notify ()

def acquire_write (self):

"" "

Verwerft een schrijfvergrendeling.

"" "

met Self.Lock:

terwijl self.read_count> 0 of self.write_count> 0 of self.writers_waiting:

self.writers_waiting.append (threading.current_thread ())

self.lock.Release ()

threading.current_thread (). Wait ()

self.lock.acquire ()

self.write_count +=1

def release_write (self):

"" "

Geeft een schrijfvergrendeling vrij.

"" "

met Self.Lock:

self.write_count -=1

if self.readers_waiting:

Reader =self.readers_waiting.pop (0)

reader.notify ()

Class Reader (threading.thread):

"" "

Een lezer thread.

"" "

def __init __ (zelf, slot):

super () .__ init __ ()

self.lock =lock

def run (self):

voor _ in bereik (5):

self.lock.acquire_read ()

print (f "Reader {self.Name} is lezen")

Time.Sleep (0,5)

self.lock.Release_read ()

print (f "Reader {self.Name} voltooid lezen")

Class Writer (threading.thread):

"" "

Een schrijver draad.

"" "

def __init __ (zelf, slot):

super () .__ init __ ()

self.lock =lock

def run (self):

voor _ in bereik (5):

self.lock.acquire_write ()

print (f "schrijver {self.Name} is aan het schrijven")

Time.Sleep (1)

self.lock.Release_write ()

print (f "schrijver {self.Name} voltooid schrijven")

if __Name__ =="__main__":

lock =readerWriterLock ()

lezers =[lezer (vergrendeling) voor _ in bereik (3)]

schrijvers =[schrijver (vergrendeling) voor _ in bereik (2)]

voor lezer in lezers:

Reader.Start ()

voor schrijver in schrijvers:

Writer.Start ()

voor lezer in lezers:

Reader.Join ()

voor schrijver in schrijvers:

schrijver.join ()

`` `

Verklaring:

1. `ReaderWriterLock' -klasse:

- `Read_Count`,` Write_Count`:volgt het aantal actieve lezers en schrijvers.

- `Readers_waiting`,` Writers_waiting`:lijsten om threads te bevatten die wachten op toegang.

- `lock`:een mutex om de kritieke sectie te beschermen waar tellers en lijsten worden gewijzigd.

2. `Acquire_read`:

- Verwerft een leesvergrendeling:

- Het controleert eerst of schrijvers momenteel toegang hebben of wachten. Als dit het geval is, wordt de lezer toegevoegd aan de lijst `lezers_waiting` en wacht.

- Zodra aan de voorwaarde is voldaan, wordt de lezer `read_count` verhoogd, wat de vermelding betekent.

3. `release_read`:

- brengt een leesvergrendeling vrij:

- Vermindert de `read_count`.

- Als er geen lezers meer actief zijn en schrijvers wachten, wordt de eerste schrijver in `schrijvers_waiting` op de hoogte gebracht.

4. `Acquire_write`:

- Verwerft een schrijfvergrendeling:

- Het controleert eerst of lezers of schrijvers momenteel toegang hebben tot of wachten. Als dat zo is, wordt de schrijver toegevoegd aan `Writers_Waiting` en wacht.

- Zodra aan de voorwaarde is voldaan, wordt de schrijver `Write_Count` verhoogd, wat de vermelding betekent.

5. `release_write`:

- geeft een schrijfvergrendeling vrij:

- Vermindert de `schrijven_count`.

- Als lezers wachten, wordt de eerste lezer in `lezers_waiting` op de hoogte gebracht.

6. `Reader` en` Writer` klassen:

- Deze klassen vertegenwoordigen lezer- en schrijverthreads.

- Ze gebruiken de methoden `acquire_read/acquire_write` en` release_read/release_write` om toegang te krijgen tot de gedeelde resource.

Hoe het werkt:

- De monitor zorgt voor exclusieve toegang tot de bron voor schrijvers.

- Lezers mogen gelijktijdig lezen, maar geen lezer kan lezen terwijl een schrijver schrijft.

- Wachtende threads worden beheerd in wachtrijen en op de hoogte gebracht wanneer de bron beschikbaar komt.

Opmerking:

- De methode `melding ()` van een thread wordt gebruikt om een ​​wachtende thread wakker te maken.

- Deze code maakt gebruik van het concept van een conditie -variabele (geïmpliceerd door `wacht ()` en `melding ()` in dit voorbeeld) om de wacht en kennisgeving van thread te verwerken.