操作系统生产者与消费者问题代码实现

以下是一个简单的生产者与消费者问题代码实现，使用 Python 语言实现：

import threading
import time

# 定义一个共享资源，表示生产者和消费者共同操作的数据
shared_resource = []

# 定义一个互斥锁，保证共享资源的安全访问
mutex = threading.Lock()

# 定义一个信号量，表示生产者可以生产的数量
semaphore = threading.Semaphore(10)

# 定义一个生产者线程类
class ProducerThread(threading.Thread):
    def run(self):
        global shared_resource
        global mutex
        global semaphore
        while True:
            # 获取信号量，如果已经达到最大数量，则阻塞等待
            semaphore.acquire()
            # 加锁，保证共享资源的安全修改
            mutex.acquire()
            # 生产一个数据，并加入共享资源中
            shared_resource.append(1)
            print("Producer produced 1, shared resource: ", shared_resource)
            # 释放锁，让其他线程可以访问共享资源
            mutex.release()
            # 休眠一段时间，模拟生产过程
            time.sleep(1)

# 定义一个消费者线程类
class ConsumerThread(threading.Thread):
    def run(self):
        global shared_resource
        global mutex
        global semaphore
        while True:
            # 加锁，保证共享资源的安全访问
            mutex.acquire()
            if len(shared_resource) > 0:
                # 消费一个数据，并从共享资源中移除
                shared_resource.pop()
                print("Consumer consumed 1, shared resource: ", shared_resource)
                # 释放锁，让其他线程可以访问共享资源
                mutex.release()
                # 释放信号量，表示可以继续生产
                semaphore.release()
            else:
                # 如果共享资源为空，则释放锁，让其他线程可以访问共享资源，并阻塞等待
                mutex.release()
                time.sleep(1)

# 创建一个生产者线程和三个消费者线程
producer_thread = ProducerThread()
consumer_thread1 = ConsumerThread()
consumer_thread2 = ConsumerThread()
consumer_thread3 = ConsumerThread()

# 启动线程
producer_thread.start()
consumer_thread1.start()
consumer_thread2.start()
consumer_thread3.start()

上述代码通过创建一个共享资源列表 `shared_resource`，一个互斥锁 `mutex`，一个信号量 `semaphore`，以及一个生产者线程和三个消费者线程来模拟生产者与消费者问题。

生产者线程通过不断地获取信号量 `semaphore`，加锁 `mutex`，向共享资源列表中添加一个数据，并释放锁 `mutex`，然后休眠一段时间，模拟生产过程。消费者线程通过加锁 `mutex`，判断共享资源列表中是否有数据可供消费，如果有则消费一个数据，并释放锁 `mutex`，然后释放信号量 `semaphore`，表示可以继续生产；如果共享资源列表为空则释放锁 `mutex`，然后阻塞等待。

通过这种方式，生产者和消费者可以安全地访问共享资源，而不会发生竞争条件或数据不一致的情况。