Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
importovaný závit
import
Čítanie triedy:
"" "
Monitorové riešenie problému čitateľov a spisovateľov.
Atribúty:
Read_count (int):Počet čitateľov, ktorí momentálne pristupujú k zdroju.
Write_count (int):Počet spisovateľov, ktorý momentálne pristupuje k zdroju.
Readers_waiting (List):Zoznam čitateľov čakajúcich na prístup k zdroju.
Writers_waiting (List):Zoznam autorov čakajúcich na prístup k zdroju.
Lock (Threading.Lock):zámok na ochranu kritickej sekcie.
"" "
def __init __ (self):
self.read_count =0
self.write_count =0
self.readers_waiting =[]
self.writers_waiting =[]
self.Lock =závit.Lock ()
def nadobudnutie_read (self):
"" "
Získava zámok na čítanie.
"" "
so self.Lock:
Zatiaľ čo self.write_count> 0 alebo self.writers_waiting:
self.readers_waiting.append (Threading.Current_thread ())
self.lock.rease ()
Threading.Current_thread (). Wait ()
self.lock.acquire ()
self.read_count +=1
DeF Release_read (self):
"" "
Uvoľňuje zámok na čítanie.
"" "
so self.Lock:
self.read_count -=1
Ak self.read_count ==0 a self.writers_waiting:
spisovateľ =self.writers_waiting.pop (0)
spisovateľ.Notify ()
def acquire_write (self):
"" "
Získa zámok zápisu.
"" "
so self.Lock:
zatiaľ čo self.read_count> 0 alebo self.write_count> 0 alebo self.writers_waiting:
self.writers_waiting.append (Threading.Current_thread ())
self.lock.rease ()
Threading.Current_thread (). Wait ()
self.lock.acquire ()
self.write_count +=1
DeF Release_Write (self):
"" "
Uvoľňuje zámok zápisu.
"" "
so self.Lock:
self.write_count -=1
Ak self.readers_waiting:
Reader =self.readers_waiting.pop (0)
Reader.Notify ()
Čítačka triedy (Threading.Thread):
"" "
Vlákno čitateľa.
"" "
def __init __ (ja, zámok):
super () .__ init __ ()
self.Lock =zámok
def run (self):
pre _ v rozsahu (5):
self.lock.acquire_read ()
print (f "reader {self.name} je čítanie")
čas.sleep (0,5)
self.lock.release_read ()
Print (F "Reader {self.name} hotové čítanie")
autor triedy (Threading.Thread):
"" "
Vlákno spisovateľa.
"" "
def __init __ (ja, zámok):
super () .__ init __ ()
self.Lock =zámok
def run (self):
pre _ v rozsahu (5):
self.lock.acquire_write ()
print (f "spisovateľ {self.name} je písanie")
Time.sleep (1)
self.lock.release_write ()
print (f "spisovateľ {self.name} hotové písanie")
Ak __name__ =="__main__":
Lock =ReaderWriterLock ()
čítačky =[čítačka (zámok) pre _ v rozsahu (3)]
spisovatelia =[spisovateľ (zámok) pre _ v rozsahu (2)]
Pre čitateľa v čitateľoch:
Reader.start ()
Pre spisovateľa v autoroch:
spisovateľ.start ()
Pre čitateľa v čitateľoch:
Reader.join ()
Pre spisovateľa v autoroch:
spisovateľ.join ()
`` `
Vysvetlenie:
1. `trieda ReaderWriterlock`:
- `read_count`,` write_count`:sleduje počet aktívnych čitateľov a autorov.
- `Readers_waiting`,` Writers_waiting`:Zoznamy na zadržiavanie vlákien čakajúcich na prístup.
- `Lock`:MUTEX na ochranu kritickej časti, kde sú upravené počítadlá a zoznamy.
2. `Získajte_read`:
- Získa zámok na čítanie:
- Najprv skontroluje, či niektorí autori momentálne pristupujú alebo čakajú. Ak áno, čitateľ sa pridá do zoznamu `Readers_waiting` a čaká.
- Akonáhle je podmienka splnená, zvyšuje sa čítačka `read_count`, čo znamená jeho vstup.
3. `Release_read`:
- Uvoľňuje zámok na čítanie:
- Zníženie `read_count`.
- Ak už nie sú aktívni už viac čitateľov a spisovatelia čakajú, je oznámený prvý spisovateľ v `autors_waiting.
4.
- Získa zámok zápisu:
- Najprv skontroluje, či niektorí čitatelia alebo spisovatelia momentálne pristupujú alebo čakajú. Ak áno, spisovateľ sa pridá do `autorov_waiting` a čaká.
- Akonáhle je podmienka splnená, zvyšuje sa spisovateľ „Write_count“, čo znamená jeho vstup.
5. `Release_write`:
- Uvoľňuje zámok zápisu:
- Zníženie `write_count`.
- Ak čitatelia čakajú, je upozornený prvý čitateľ v `Readers_waiting`.
6.
- Tieto triedy predstavujú vlákna čitateľa a spisovateľa.
- Používajú metódy `cupire_read/cvare_write` a` Release_read/Release_write` na prístup k zdieľanému prostriedku.
Ako to funguje:
- Monitor zaisťuje exkluzívny prístup k zdroju spisovateľov.
- Čitatelia môžu čítať súčasne, ale žiadny čitateľ nemôže čítať, zatiaľ čo spisovateľ píše.
- Čakajúce vlákna sú spravované vo frontoch a upozornené, keď je zdroj k dispozícii.
Poznámka:
- Metóda notify () `` Metóda vlákna sa používa na prebudenie čakajúceho vlákna.
- Tento kód využíva koncept premennej podmienky (predpokladanej podľa `wait ()` a `notify ()` v tomto príklade) na spracovanie čakania a upozornenia vlákna.