用python实现以下功能创建有界缓冲池，可以设置缓冲池大小。 创建生产者和消费者线程，它们共享同一个缓冲池。 生产者线程可以向缓冲池中放入消息（数据），只要缓冲池未满。 消费者线程可以从缓冲池中取出消息（数据），只要缓冲池未空。 当缓冲池已满时，生产者线程应该等待，直到有空闲空间。 当缓冲池已空时，消费者线程应该等待，直到有可用数据。 程序应该能够显示缓冲池状态，包括当前缓冲池中的消息数量和空闲空间数量。 程序应该能够让用户手动停止生产者和消费者线程，以便测试程序的正确性。 程序应该能够正确处理线程的同步和互斥问题，避免出现死锁和竞态条件等问题。 程序应该能够处理异常情况，如线程被中断或者缓冲池已满但生产者仍然试图放入消息等情况。

好的，我可以为您提供一个Python实现的有界缓冲池，满足您的需求。代码如下所示：

import threading
import queue
import time

class BoundedBuffer:
    def __init__(self, maxsize):
        self.maxsize = maxsize
        self.buffer = queue.Queue(maxsize)
        self.mutex = threading.Lock()
        self.empty = threading.Condition(self.mutex)
        self.full = threading.Condition(self.mutex)

    def put(self, item):
        with self.full:
            while self.buffer.full():
                self.full.wait()
            self.buffer.put(item)
            self.empty.notify()

    def get(self):
        with self.empty:
            while self.buffer.empty():
                self.empty.wait()
            item = self.buffer.get()
            self.full.notify()
            return item

    def get_buffer_info(self):
        with self.mutex:
            return {'size': self.buffer.qsize(), 'maxsize': self.maxsize}

class Producer(threading.Thread):
    def __init__(self, buffer):
        threading.Thread.__init__(self)
        self.buffer = buffer
        self.stop_event = threading.Event()

    def run(self):
        while not self.stop_event.is_set():
            item = time.time() # 生产一个元素
            self.buffer.put(item)
            print(f'生产者 {self.name} 生产了一个元素 {item}')
            time.sleep(1)

    def stop(self):
        self.stop_event.set()

class Consumer(threading.Thread):
    def __init__(self, buffer):
        threading.Thread.__init__(self)
        self.buffer = buffer
        self.stop_event = threading.Event()

    def run(self):
        while not self.stop_event.is_set():
            item = self.buffer.get()
            print(f'消费者 {self.name} 消费了一个元素 {item}')
            time.sleep(1)

    def stop(self):
        self.stop_event.set()

if __name__ == '__main__':
    buffer = BoundedBuffer(5)
    producers = [Producer(buffer) for i in range(2)]
    consumers = [Consumer(buffer) for i in range(3)]
    for p in producers:
        p.start()
    for c in consumers:
        c.start()

    while True:
        try:
            time.sleep(5)
            print(f'缓冲池状态: {buffer.get_buffer_info()}')
        except KeyboardInterrupt:
            print('停止生产者和消费者线程...')
            for p in producers:
                p.stop()
            for c in consumers:
                c.stop()
            break

在上面的代码中，我们首先定义了一个 `BoundedBuffer` 类，这个类封装了一个有界缓冲池，并提供了 `put` 和 `get` 方法，用于往缓冲池中放入和取出元素。缓冲池的实现使用了 Python 的 `queue.Queue` 类，这个类本身就是线程安全的，所以不需要再使用锁进行同步。

在 `BoundedBuffer` 类中，我们使用了三个锁：`mutex`、`empty` 和 `full`。其中，`mutex` 是用于保护缓冲池的数据结构，`empty` 和 `full` 分别是用于控制消费者和生产者的等待条件。当缓冲池为空时，消费者会等待 `empty` 条件变量，当缓冲池为满时，生产者会等待 `full` 条件变量。

然后，我们定义了 `Producer` 和 `Consumer` 两个类，分别表示生产者和消费者线程。这两个类都继承自 `threading.Thread` 类，并实现了 `run` 方法。在 `run` 方法中，生产者会不断地向缓冲池中放入元素，而消费者会不断地从缓冲池中取出元素。这里我们使用了一个 `stop_event` 变量，用于控制线程的停止。

最后，在主程序中，我们创建了两个生产者和三个消费者线程，并启动它们。同时，我们也启动了一个循环，每隔一段时间就打印出缓冲池的状态。当用户按下 Ctrl+C 时，程序会捕捉到 `KeyboardInterrupt` 异常，然后停止生产者和消费者线程，退出程序。

综上所述，这个程序实现了有界缓冲池的基本功能，包括线程的同步和互斥、异常处理、状态显示等。您可以根据需要进行修改和扩展。