利用记录型信号量解决读者-写者问题完整代码

读者-写者问题是经典的问题，通常涉及两个互斥操作：读取和写入共享资源，以及多个并发的读者可以同时访问资源而无需阻塞。利用记录型信号量（也称为条件变量）可以在Python的threading模块中解决这个问题。下面是一个简单的Python代码示例：

import threading

class ReaderWriterSemaphore:
    def __init__(self, readers=0, writers=1):
        self.readers = readers
        self.writers = writers
        self.condition = threading.Condition()

    def acquire_reader(self):
        with self.condition:
            while self.writers == 0 and self.readers > 0:
                self.condition.wait()
            self.readers += 1

    def release_reader(self):
        with self.condition:
            self.readers -= 1
            if self.readers == 0 and self.writers < self.MAX_WRITERS:  # 假设 MAX_WRITERS 是最大允许的写者数
                self.writers += 1
                self.condition.notify_all()  # 当所有读者释放完毕后唤醒等待的写者

    def acquire_writer(self):
        with self.condition:
            while self.writers >= self.MAX_WRITERS or self.readers > 0:
                self.condition.wait()
            self.writers += 1

    def release_writer(self):
        with self.condition:
            self.writers -= 1
            self.condition.notify_all()  # 当写者完成工作后，通知等待的读者和写者

# 示例使用
semaphore = ReaderWriterSemaphore(3)  # 允许最多3个同时读取
threads = []

def reader_task():
    for _ in range(5):  # 模拟5次阅读请求
        semaphore.acquire_reader()
        print(f"Reader {threading.current_thread().name} is reading")
        semaphore.release_reader()

def writer_task():
    for _ in range(2):  # 模拟2次写作请求
        semaphore.acquire_writer()
        print(f"Writer {threading.current_thread().name} is writing")
        semaphore.release_writer()

for i in range(5):  # 创建5个读线程和2个写线程
    t = threading.Thread(target=(reader_task if i % 2 else writer_task))
    threads.append(t)
    t.start()
    
for t in threads:
    t.join()