操作系统读者写者问题代码

读者写者问题是操作系统中的一个经典问题，主要涉及到多个线程同时访问共享资源的问题。下面是一个简单的Python实现，其中使用了读写锁来实现对共享资源的互斥访问。

import threading
class ReadWriteLock:
    def __init__(self):
        self._read_lock = threading.Lock()
        self._write_lock = threading.Lock()
        self._read_count = 0

    def acquire_read(self):
        with self._read_lock:
            self._read_count += 1
            if self._read_count == 1:
                self._write_lock.acquire()

    def release_read(self):
        with self._read_lock:
            self._read_count -= 1
            if self._read_count == 0:
                self._write_lock.release()

    def acquire_write(self):
        self._write_lock.acquire()

    def release_write(self):
        self._write_lock.release()

class Reader(threading.Thread):
    def __init__(self, name, lock, data):
        threading.Thread.__init__(self)
        self.name = name
        self.lock = lock
        self.data = data

    def run(self):
        while True:
            self.lock.acquire_read()
            print("{} is reading data: {}".format(self.name, self.data))
            self.lock.release_read()

class Writer(threading.Thread):
    def __init__(self, name, lock, data):
        threading.Thread.__init__(self)
        self.name = name
        self.lock = lock
        self.data = data

    def run(self):
        while True:
            self.lock.acquire_write()
            self.data += 1
            print("{} is writing data: {}".format(self.name, self.data))
            self.lock.release_write()

if __name__ == '__main__':
    lock = ReadWriteLock()
    data = 0
    readers = [Reader("Reader{}".format(i), lock, data) for i in range(5)]
    writer = Writer("Writer", lock, data)

    for reader in readers:
        reader.start()
    writer.start()

上述代码中，我们定义了一个ReadWriteLock类，其中包含了读锁和写锁。读锁可以被多个线程同时获取，但是写锁只能被一个线程获取。在读者线程中，我们使用了acquire_read()和release_read()方法来获取和释放读锁，在写者线程中，我们使用了acquire_write()和release_write()方法来获取和释放写锁。