根据上文代码实现实现多个生产者多个消费者共享缓冲区（要求：3个生产者3个消费者共享缓冲区，不要一直循环生产）

下面是一个基于Python多线程实现的多个生产者多个消费者共享缓冲区的示例代码：

import threading
import time
import random

# 缓冲区大小
BUFFER_SIZE = 5

# 生产者数量
PRODUCER_COUNT = 3

# 消费者数量
CONSUMER_COUNT = 3

# 缓冲区
buffer = []
# 缓冲区锁
buffer_lock = threading.Lock()

# 生产者类
class Producer(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        global buffer, buffer_lock
        while True:
            # 随机生成一个数字
            data = random.randint(0, 100)
            # 获取缓冲区锁
            buffer_lock.acquire()
            # 如果缓冲区已满，等待
            while len(buffer) >= BUFFER_SIZE:
                buffer_lock.release()
                time.sleep(random.random())
                buffer_lock.acquire()
            # 将数据加入缓冲区
            buffer.append(data)
            print('[Producer %s]: produce data %d, buffer size is %d' % (self.name, data, len(buffer)))
            # 释放缓冲区锁
            buffer_lock.release()
            # 等待一段时间
            time.sleep(random.random())

# 消费者类
class Consumer(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        global buffer, buffer_lock
        while True:
            # 获取缓冲区锁
            buffer_lock.acquire()
            # 如果缓冲区为空，等待
            while len(buffer) == 0:
                buffer_lock.release()
                time.sleep(random.random())
                buffer_lock.acquire()
            # 从缓冲区取出数据
            data = buffer.pop(0)
            print('[Consumer %s]: consume data %d, buffer size is %d' % (self.name, data, len(buffer)))
            # 释放缓冲区锁
            buffer_lock.release()
            # 等待一段时间
            time.sleep(random.random())

# 创建生产者线程
producers = []
for i in range(PRODUCER_COUNT):
    producer = Producer(str(i))
    producers.append(producer)

# 创建消费者线程
consumers = []
for i in range(CONSUMER_COUNT):
    consumer = Consumer(str(i))
    consumers.append(consumer)

# 启动所有线程
threads = producers + consumers
for thread in threads:
    thread.start()

# 等待所有线程执行完毕
for thread in threads:
    thread.join()

在上面的代码中，我们首先定义了缓冲区大小、生产者数量、消费者数量等常量，然后定义了生产者和消费者类，并在其中实现了对缓冲区的操作。在主函数中，我们首先创建了多个生产者和消费者线程，并启动了这些线程。最后，我们等待所有线程执行完毕，程序结束运行。

需要注意的是，在多个线程同时对缓冲区进行操作时，为了避免出现竞争条件，我们使用了一个缓冲区锁来保证线程安全。生产者在向缓冲区中添加数据时需要获取锁，消费者在从缓冲区中取出数据时也需要获取锁。这样可以保证同一时间只有一个线程能够对缓冲区进行操作，避免了线程之间的竞争。