`` `python
importtrådning
importtid
Klass ReaderWriterLock:
"" "
En monitorlösning för problem med läsare-författare.
Attribut:
Read_Count (int):Antal läsare som för närvarande har tillgång till resursen.
Write_Count (int):Antal författare som för närvarande får tillgång till resursen.
Readers_Waiting (lista):Lista över läsare som väntar på att komma åt resursen.
Writers_Waiting (lista):Lista över författare som väntar på att få tillgång till resursen.
lås (gängor):Ett lås för att skydda det kritiska avsnittet.
"" "
def __init __ (själv):
self.read_count =0
self.write_count =0
self.readers_waiting =[]
self.writers_waiting =[]
self.lock =threading.lock ()
def acquire_read (self):
"" "
Förvärvar ett läslås.
"" "
med själv.lock:
medan self.write_count> 0 eller self.writers_waiting:
self.readers_waiting.append (threading.current_thread ())
self.lock.release ()
gängande.current_thread (). vänta ()
self.lock.acquire ()
self.read_count +=1
def release_read (self):
"" "
Släpper ett läslås.
"" "
med själv.lock:
self.read_count -=1
om self.read_count ==0 och self.writers_waiting:
författare =self.writers_waiting.pop (0)
Writer.notify ()
def acquire_write (self):
"" "
Förvärvar ett skrivlås.
"" "
med själv.lock:
medan self.read_count> 0 eller self.write_count> 0 eller self.writers_waiting:
self.writers_waiting.append (threading.current_thread ())
self.lock.release ()
gängande.current_thread (). vänta ()
self.lock.acquire ()
self.write_count +=1
def release_write (self):
"" "
Släpper ett skrivlås.
"" "
med själv.lock:
self.write_count -=1
om self.readers_waiting:
läsare =self.readers_waiting.pop (0)
läsare.notify ()
Klassläsare (tråd. Thread):
"" "
En läsartråd.
"" "
def __init __ (själv, lås):
super () .__ init __ ()
self.lock =lås
def run (self):
för _ inom intervallet (5):
self.lock.acquire_read ()
tryck (F "Reader {self.name} är läsning")
tid. sömn (0,5)
self.lock.release_read ()
tryck (f "Reader {self.name} färdig läsning")
Klassförfattare (tråd. Thread):
"" "
En författartråd.
"" "
def __init __ (själv, lås):
super () .__ init __ ()
self.lock =lås
def run (self):
för _ inom intervallet (5):
self.lock.acquire_write ()
tryck (F "Writer {self.name} är skriver")
tid. sömn (1)
self.lock.release_write ()
tryck (F "Writer {self.name} färdig att skriva")
om __name__ =="__main__":
Lock =ReaderWriterLock ()
läsare =[läsare (lås) för _ inom intervallet (3)]
författare =[författare (lås) för _ inom intervallet (2)]
För läsare i läsarna:
läsare.start ()
För författare i författare:
Writer.start ()
För läsare i läsarna:
läsare.join ()
För författare i författare:
Writer.Join ()
`` `
Förklaring:
1. `ReaderWriterLock` klass:
- `Read_count`,` write_count`:spårar antalet aktiva läsare och författare.
- `Readers_waiting ',` Writers_Waiting':Listor för att hålla trådar som väntar på åtkomst.
- `Lock`:En mutex för att skydda det kritiska avsnittet där räknare och listor modifieras.
2. `Acquire_read`:
- förvärvar ett läslås:
- Det kontrollerar först om några författare för närvarande har tillgång till eller väntar. I så fall läggs läsaren till listan "Readers_waiting" och väntar.
- När villkoret är uppfyllt ökas läsarens "Read_Count", vilket betyder att dess inträde.
3. `Release_read`:
- släpper ett läslås:
- minskar "read_count".
- Om inga fler läsare är aktiva och författare väntar, meddelas den första författaren i "Writers_Waiting".
4. `Acquire_Write`:
- förvärvar ett skrivlås:
- Det kontrollerar först om några läsare eller författare för närvarande har tillgång till eller väntar. Om så är fallet, läggs författaren till "Writers_Waiting" och väntar.
- När villkoret är uppfyllt ökas författarens "Write_Count", vilket betyder att dess inträde.
5. `Release_write`:
- släpper ett skrivlås:
- minskar `write_count '.
- Om läsarna väntar, meddelas den första läsaren i "Readers_Waiting".
6. `Reader` och` Writer` klasser:
- Dessa klasser representerar läsare och författartrådar.
- De använder metoderna "Acquire_Read/Acquire_Write" och "Release_read/Release_Write" för att få tillgång till den delade resursen.
Hur det fungerar:
- Monitorn säkerställer exklusiv tillgång till resursen för författare.
- Läsarna får läsa samtidigt, men ingen läsare kan läsa medan en författare skriver.
- Vänttrådar hanteras i kö och meddelas när resursen blir tillgänglig.
Obs:
- Metoden `Notify () 'för en tråd används för att väcka en väntetråd.
- Den här koden använder konceptet med en tillståndsvariabel (underförstått av `vänta ()` och `meddela ()` i det här exemplet) för att hantera trådvänt och anmälan.
