生产者﹣消费者问题（计算机系统中的许多问题都可归结为此问题）描述如下：生产者与消费者可以通过一个环形缓冲池联系起来，环形缓冲池由几个大小相等的缓冲块组成，每个缓冲块容纳一个产品。每个生产者可不断地每次往缓冲池中送一个生产产品，而每个消费者则可不断地每次从缓冲池中取出一个产品。编写程序模拟多个生产者和多个消费者共享缓冲池的生产和消费过程。 要求： 1．设计信号量用于进行生产者﹣消费者、生产者﹣生产者、消费者﹣消费者之间的同步控制；2．创建多个（不少于5个）进程或者线程模拟生产者和消费者： 3．缓冲池大小定义在10-20，缓冲块中的产品为数据； 4．程序运行结果能实时显示缓冲池中生产和消费产品的过程，包括断点、推进时间、次序等，编程语言可选用 C 、 C ++、 Java 或者 Python 。

这是一个经典的操作系统并发编程问题，可以使用信号量来实现生产者和消费者之间的同步控制。

首先，需要定义一个环形缓冲池，可以使用一个数组来实现。缓冲池大小定义在10-20之间，缓冲块中的产品为数据。每个缓冲块需要定义一个信号量，用于同步生产者和消费者之间的操作。

然后，创建多个进程或者线程模拟生产者和消费者。每个生产者进程/线程会不断地往缓冲池中送一个生产产品，每个消费者进程/线程会不断地从缓冲池中取出一个产品。

在进行生产和消费操作时，需要加锁保证同一时间只有一个生产者或者消费者进行操作。具体实现可以使用信号量来控制。

程序运行结果能实时显示缓冲池中生产和消费产品的过程，包括断点、推进时间、次序等。可以使用打印语句来实现。

以下是一个可能的实现，使用Python语言和threading模块：

import threading
import time
import random

# 定义缓冲池大小
BUFFER_SIZE = random.randint(10, 20)
# 定义缓冲池
buffer = [None] * BUFFER_SIZE
# 定义每个缓冲块的信号量
semaphores = [threading.Semaphore(1) for _ in range(BUFFER_SIZE)]
# 定义生产者数量和消费者数量
NUM_PRODUCERS = 5
NUM_CONSUMERS = 5

# 定义生产者线程类
class ProducerThread(threading.Thread):
    def __init__(self, id):
        super().__init__()
        self.id = id

    def run(self):
        while True:
            item = random.randint(1, 100)
            print(f"Producer {self.id} produced item {item}")
            # 获取空闲的缓冲块
            index = -1
            for i in range(BUFFER_SIZE):
                if semaphores[i].acquire(blocking=False):
                    index = i
                    break
            if index == -1:
                print(f"Producer {self.id} waiting for buffer space")
            else:
                buffer[index] = item
                print(f"Producer {self.id} put item {item} in buffer {index}")
                semaphores[index].release()
                time.sleep(random.uniform(0, 1))


# 定义消费者线程类
class ConsumerThread(threading.Thread):
    def __init__(self, id):
        super().__init__()
        self.id = id

    def run(self):
        while True:
            # 获取有数据的缓冲块
            index = -1
            for i in range(BUFFER_SIZE):
                if semaphores[i].acquire(blocking=False):
                    if buffer[i] is not None:
                        index = i
                        break
                    else:
                        semaphores[i].release()
            if index == -1:
                print(f"Consumer {self.id} waiting for items")
            else:
                item = buffer[index]
                buffer[index] = None
                print(f"Consumer {self.id} got item {item} from buffer {index}")
                semaphores[index].release()
                time.sleep(random.uniform(0, 1))


# 创建生产者和消费者线程
producers = [ProducerThread(i) for i in range(NUM_PRODUCERS)]
consumers = [ConsumerThread(i) for i in range(NUM_CONSUMERS)]

# 启动线程
for producer in producers:
    producer.start()

for consumer in consumers:
    consumer.start()

# 等待所有线程结束
for producer in producers:
    producer.join()

for consumer in consumers:
    consumer.join()

在这个实现中，每个生产者和消费者线程会不断地进行生产和消费操作，使用信号量来控制同步。通过打印语句，可以实时显示缓冲池中生产和消费产品的过程，包括断点、推进时间、次序等。