|
`` Python
Filation d'importation
heure d'importation
classe ReaderWriterlock:
"" "
Une solution de moniteur pour le problème des lecteurs-écrivains.
Attributs:
read_count (int):le nombre de lecteurs accédant actuellement à la ressource.
write_count (int):le nombre d'écrivains accédant actuellement à la ressource.
Readers_Waiting (liste):Liste des lecteurs en attente d'accéder à la ressource.
Writers_Waiting (liste):Liste des écrivains attendant d'accéder à la ressource.
Lock (Threading.lock):un verrou pour protéger la section critique.
"" "
def __init __ (soi):
self.read_count =0
self.write_count =0
self.readers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
def acquire_read (self):
"" "
Acquiert une serrure de lecture.
"" "
avec le bloc de soi:
tandis que self.write_count> 0 ou 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):
"" "
Libère un verrouillage de lecture.
"" "
avec le bloc de soi:
self.read_count - =1
si self.read_count ==0 et self.writers_waiting:
écrivain =self.writers_waiting.pop (0)
écrivain.notify ()
def acquire_write (self):
"" "
Acquiert un verrouillage d'écriture.
"" "
avec le bloc de soi:
while self.read_count> 0 ou self.write_count> 0 ou 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):
"" "
Libère un verrouillage d'écriture.
"" "
avec le bloc de soi:
self.write_count - =1
Si self.readers_waiting:
lecteur =self.readers_waiting.pop (0)
Reader.Notify ()
lecteur de classe (threading.thread):
"" "
Un fil de lecteur.
"" "
def __init __ (self, verrouillage):
super () .__ init __ ()
Self.lock =Lock
def run (self):
pour _ dans la gamme (5):
self.lock.acquire_read ()
print (f "Reader {self.name} est lit")
Temps.
self.lock.release_read ()
print (f "Reader {self.name} Reading fini")
écrivain de classe (threading.thread):
"" "
Un fil d'écrivain.
"" "
def __init __ (self, verrouillage):
super () .__ init __ ()
Self.lock =Lock
def run (self):
pour _ dans la gamme (5):
self.lock.acquire_write ()
print (f "écrivain {self.name} écrit")
Temps.
self.lock.release_write ()
print (f "écrivain {self.name} Écriture finie")
Si __name__ =="__main__":
Lock =ReaderWriterLock ()
lecteurs =[lecteur (verrouillage) pour _ dans la plage (3)]
écrivains =[écrivain (verrouillage) pour _ dans la plage (2)]
Pour lecteur dans les lecteurs:
Reader.start ()
Pour l'écrivain en écrivains:
writer.start ()
Pour lecteur dans les lecteurs:
lecteur.join ()
Pour l'écrivain en écrivains:
écrivain.join ()
`` '
Explication:
1. `ReaderWriterLock` Classe:
- `read_count`,` write_count`:suit le nombre de lecteurs et d'écrivains actifs.
- `Readers_waiting`,` writers_waiting`:listes pour maintenir les threads en attente d'accès.
- «Lock»:un mutex pour protéger la section critique où les compteurs et les listes sont modifiés.
2. `Acquire_read`:
- acquiert une serrure de lecture:
- Il vérifie d'abord si des rédacteurs accèdent ou attendent actuellement. Si c'est le cas, le lecteur est ajouté à la liste et attend la liste `Readers_waiting`.
- Une fois la condition remplie, le `LEAD_COUNT` du lecteur est incrémenté, ce qui signifie son entrée.
3. `release_read`:
- libère un verrouillage de lecture:
- diminue le `read_count`.
- Si plus les lecteurs sont actifs et que les scénaristes attendent, le premier écrivain dans `Writers_waiting` est notifié.
4. `acquire_write`:
- acquiert un verrouillage d'écriture:
- Il vérifie d'abord si des lecteurs ou des écrivains accéder ou attendent actuellement. Si c'est le cas, l'écrivain est ajouté à `Writers_waiting` and Waits.
- Une fois la condition remplie, le `Write_Count` de l'écrivain est incrémenté, ce qui signifie son entrée.
5. `release_write`:
- libère un verrouillage d'écriture:
- diminue le `write_count`.
- Si les lecteurs attendent, le premier lecteur dans `Readers_waiting` est informé.
6. `Reader` et« écrivain »Classes:
- Ces classes représentent des fils de lecteur et d'écrivain.
- Ils utilisent les méthodes `acquire_read / acquire_write` et` release_read / release_write` pour accéder à la ressource partagée.
comment cela fonctionne:
- Le moniteur assure un accès exclusif à la ressource pour les écrivains.
- Les lecteurs sont autorisés à lire simultanément, mais aucun lecteur ne peut lire pendant qu'un écrivain écrit.
- Les fils d'attente sont gérés dans les files d'attente et informés lorsque la ressource devient disponible.
Remarque:
- La méthode `notify () 'd'un thread est utilisée pour réveiller un fil d'attente.
- Ce code utilise le concept d'une variable de condition (implicite par `attendre ()` et `notify () 'dans cet exemple) pour gérer l'attente et la notification du thread.
|
