threading di importazione
tempo di importazione
Readerwriterlock di classe:
"" "
Una soluzione di monitor per il problema dei lettori degli scrittori.
Attributi:
Read_Count (int):numero di lettori che attualmente accedono alla risorsa.
write_count (int):numero di scrittori che attualmente accedono alla risorsa.
Readers_Waiting (elenco):elenco di lettori in attesa di accedere alla risorsa.
Writers_waiting (elenco):elenco di scrittori in attesa di accedere alla risorsa.
blocco (threading.lock):un blocco per proteggere la sezione critica.
"" "
def __init __ (self):
self.read_count =0
self.Write_Count =0
self.readers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
def acquisire_read (self):
"" "
Acquisisce un blocco di lettura.
"" "
con self.lock:
mentre self.write_count> 0 o self.writers_waiting:
self.readers_waiting.append (threading.current_thread ())
self.lock.release ()
threading.current_thread (). wait ()
self.lock.accire ()
self.read_count +=1
def release_read (self):
"" "
Rilascia un blocco di lettura.
"" "
con self.lock:
self.read_count -=1
if self.read_count ==0 e self.writers_waiting:
writer =self.writers_waiting.pop (0)
writer.notify ()
def acquisire_write (self):
"" "
Acquisisce un blocco di scrittura.
"" "
con self.lock:
mentre self.read_count> 0 o self.write_count> 0 o self.writers_waiting:
self.writers_waiting.append (threading.current_thread ())
self.lock.release ()
threading.current_thread (). wait ()
self.lock.accire ()
self.Write_Count +=1
def release_write (self):
"" "
Rilascia un blocco di scrittura.
"" "
con self.lock:
self.Write_Count -=1
Se self.reders_waiting:
lettore =self.readers_waiting.pop (0)
lettore.notify ()
Class Reader (Threading.Thread):
"" "
Un thread del lettore.
"" "
def __init __ (self, blocco):
super () .__ init __ ()
self.lock =blocco
def run (self):
per _ nell'intervallo (5):
self.lock.accire_read ()
print (f "reader {self.name} è la lettura")
Time.sleep (0,5)
self.lock.release_read ()
print (f "lettore {self.name} lettura finita")
Class Writer (Threading.Thread):
"" "
Un filo scrittore.
"" "
def __init __ (self, blocco):
super () .__ init __ ()
self.lock =blocco
def run (self):
per _ nell'intervallo (5):
self.lock.accire_write ()
print (f "writer {self.name} is Writing")
time.sleep (1)
self.lock.release_write ()
print (f "writer {self.name} writing")
Se __Name__ =="__main__":
Lock =ReaderWriterLock ()
lettori =[lettore (blocco) per _ nell'intervallo (3)]
Writers =[Writer (Lock) per _ nell'intervallo (2)]
Per lettore nei lettori:
lettore.start ()
Per lo scrittore negli scrittori:
writer.start ()
Per lettore nei lettori:
Reader.Join ()
Per lo scrittore negli scrittori:
writer.Join ()
`` `
Spiegazione:
1. `Readerwriterlock` Classe:
- `read_count`,` write_count`:traccia il numero di lettori e scrittori attivi.
- `Readers_waiting`,` Writers_waiting`:elenchi per contenere thread in attesa di accesso.
- `Lock`:un mutex per proteggere la sezione critica in cui i contatori e gli elenchi vengono modificati.
2. `acquisito_read`:
- Acquisisce un blocco di lettura:
- Prima controlla se gli scrittori stanno attualmente accedendo o attendendo. In tal caso, il lettore viene aggiunto all'elenco "Readers_Waiting` e aspetta.
- Una volta soddisfatta la condizione, il lettore `read_count` è incrementato, significando la sua voce.
3. `rilascio_read`:
- Rilascia un blocco di lettura:
- Riduce il `read_count`.
- Se non sono più attivi i lettori e gli scrittori stanno aspettando, il primo scrittore in `Writers_Waiting` viene avvisato.
4. `acquisito_write`:
- Acquisisce un blocco di scrittura:
- Prima controlla se i lettori o gli scrittori stanno attualmente accedendo o attendendo. In tal caso, lo scrittore viene aggiunto a `writers_waiting` e aspetta.
- Una volta soddisfatta la condizione, lo scrittore `write_count` è incrementato, significando la sua voce.
5. `rilascio_write`:
- Rilascia un blocco di scrittura:
- Riduce il `write_count`.
- Se i lettori stanno aspettando, il primo lettore in `Readers_Waiting` viene avvisato.
6. `Reader` e` Writer` Classi:
- Queste classi rappresentano thread di lettore e scrittore.
- Usano i metodi `acquisito_read/acquisire_write` e` rilascio_read/rilascio_write` per accedere alla risorsa condivisa.
Come funziona:
- Il monitor garantisce l'accesso esclusivo alla risorsa per gli scrittori.
- I lettori possono leggere contemporaneamente, ma nessun lettore può leggere mentre uno scrittore sta scrivendo.
- I thread in attesa sono gestiti in code e notificati quando la risorsa diventa disponibile.
Nota:
- Il metodo `Notify ()` di un thread viene utilizzato per svegliare un thread in attesa.
- Questo codice utilizza il concetto di una variabile di condizione (implicita da `wait ()` e `notify ()` In questo esempio) per gestire l'attesa e la notifica del thread.
hardware © www.354353.com