Importación de hilo
tiempo de importación
clase ReaderWriterLock:
"" "
Una solución de monitor para el problema de los lectores-escritores.
Atributos:
Read_count (int):número de lectores que actualmente acceden al recurso.
Write_Count (int):número de escritores que actualmente acceden al recurso.
Readers_waiting (lista):Lista de lectores que esperan acceder al recurso.
Writers_Waiting (Lista):Lista de escritores que esperan acceder al recurso.
LOCK (hilting.lock):un bloqueo para proteger la sección crítica.
"" "
def __init __ (self):
self.read_count =0
self.write_count =0
Seladers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
Def adquirir_read (self):
"" "
Adquiere un bloqueo de lectura.
"" "
con self.lock:
mientras que self.write_count> 0 o self.writers_waiting:
Seladers_waiting.append (Threading.Current_Thread ())
self.lock.Release ()
Threading.Current_Thread (). Wait ()
self.lock.acquire ()
self.read_count +=1
Def versión_read (self):
"" "
Libera un bloqueo de lectura.
"" "
con self.lock:
self.read_count -=1
Si self.read_count ==0 y self.writers_waiting:
escritor =self.writers_waiting.pop (0)
escritor.notify ()
Def adquirir_write (self):
"" "
Adquiere un bloqueo de escritura.
"" "
con self.lock:
mientras que 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.acquire ()
self.write_count +=1
Def Release_Write (self):
"" "
Libera un bloqueo de escritura.
"" "
con self.lock:
self.write_count -=1
Si self.readers_waiting:
lector =self.readers_waiting.pop (0)
lector.notify ()
lector de clases (Threading.thread):
"" "
Un hilo del lector.
"" "
def __init __ (self, bloqueo):
super () .__ init __ ()
self.lock =bloqueo
Def Run (Self):
para _ en el rango (5):
self.lock.acquire_read ()
print (f "lector {self.name} está leyendo")
tiempo. Duerme (0.5)
self.lock.Release_read ()
print (f "lector {self.name} terminó la lectura")
Escritor de clases (Threading.thread):
"" "
Un hilo de escritor.
"" "
def __init __ (self, bloqueo):
super () .__ init __ ()
self.lock =bloqueo
Def Run (Self):
para _ en el rango (5):
self.lock.acquire_write ()
print (f "escritor {self.name} está escribiendo")
tiempo. Duerme (1)
self.lock.release_write ()
imprime (f "escritor {self.name} terminó la escritura")
Si __name__ =="__main__":
LOCK =ReaderWriterLock ()
lectores =[lector (bloqueo) para _ en el rango (3)]
escritores =[escritor (bloqueo) para _ en el rango (2)]
Para el lector en los lectores:
lector.start ()
Para escritor en escritores:
Writer.Start ()
Para el lector en los lectores:
Reader.Join ()
Para escritor en escritores:
Writer.Join ()
`` `` ``
Explicación:
1. `ReaderWriterLock` Clase:
- `Read_count`,` Write_Count`:rastrea el número de lectores y escritores activos.
- `Readers_waiting`,` Writers_Waiting`:listas para contener hilos esperando acceso.
- `LOCK ':un mutex para proteger la sección crítica donde se modifican los contadores y listas.
2. `adquirir_read`:
- adquiere un bloqueo de lectura:
- Primero verifica si actualmente algún escritor está accediendo o esperando. Si es así, el lector se agrega a la lista 'Readers_waiting' y espera.
- Una vez que se cumple la condición, el `read_count` del lector se incrementa, lo que significa su entrada.
3. `Release_read`:
- Libera un bloqueo de lectura:
- disminuye el `read_count`.
- Si no más lectores están activos y los escritores están esperando, se notifica al primer escritor en 'Writers_Waiting`.
4. `adquirir_write`:
- adquiere un bloqueo de escritura:
- Primero verifica si actualmente actúan o esperan lectores o escritores. Si es así, el escritor se agrega a `Writers_Waiting` y Waits.
- Una vez que se cumple la condición, se incrementa el `Write_Count` del escritor, lo que significa su entrada.
5. `Release_Write`:
- Libera un bloqueo de escritura:
- disminuye el `write_count`.
- Si los lectores están esperando, se notifica al primer lector en 'Readers_Waiting`.
6. `Reader` y` Writer` clases:
- Estas clases representan hilos de lector y escritor.
- Utilizan los métodos `adquire_read/adquire_write` y` versión_read/versión_write` para acceder al recurso compartido.
Cómo funciona:
- El monitor garantiza el acceso exclusivo al recurso para los escritores.
- Los lectores pueden leer simultáneamente, pero ningún lector puede leer mientras un escritor está escribiendo.
- Los hilos de espera se gestionan en colas y se notifican cuando el recurso está disponible.
nota:
- El método `notify ()` de un hilo se usa para despertar un hilo de espera.
- Este código utiliza el concepto de una variable de condición (implícita con `wait ()` y `notify ()` en este ejemplo) para manejar la espera y la notificación de hilo.