利用BoundedSemaphore()实现线程之间的资源共享和同步

使用BoundedSemaphore类可以实现线程之间的资源共享和同步，可以用于控制同时访问某个资源的线程数量。BoundedSemaphore类是Semaphore类的子类，它使用一个计数器来限制并发访问的数量，并且在达到最大数量时会阻塞其他线程的访问。

下面是一个使用BoundedSemaphore的例子，假设有一个资源池，资源池中有10个资源，通过多个线程同时访问资源池，并使用资源。但是最多只能有3个线程同时访问资源池，其他线程需要等待。

import threading
import time

class ResourcePool:
    def __init__(self, size):
        self.size = size
        self.pool = [i for i in range(1, size+1)]
        self.semaphore = threading.BoundedSemaphore(3)

    def use_resource(self):
        self.semaphore.acquire()  # 等待直到有资源可用
        resource = self.pool.pop()
        print(f"Thread {threading.current_thread().name} is using resource {resource}")
        time.sleep(2)  # 模拟使用资源的耗时操作
        self.pool.append(resource)
        print(f"Thread {threading.current_thread().name} released resource {resource}")
        self.semaphore.release()  # 释放资源

def worker(pool):
    pool.use_resource()

if __name__ == "__main__":
    pool = ResourcePool(10)
    threads = []
    for i in range(5):
        t = threading.Thread(target=worker, args=(pool,))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

在上面的例子中，我们首先定义了一个ResourcePool类，它维护了一个有限的资源池。在构造函数中，我们初始化了一个大小为10的资源池，并创建了一个BoundedSemaphore对象，初始计数设置为3，表示同时最多有3个线程可以访问资源池。

然后，我们定义了一个use_resource()方法，该方法模拟了线程使用资源池的场景。在调用use_resource()方法时，线程会尝试获取一个资源，如果当前没有可用的资源，那么线程会被阻塞，直到有资源可用。获取到资源后，线程会使用资源，并在2秒后释放资源，然后释放semaphore对象。

接下来，在worker函数中，我们创建了5个线程来模拟资源的使用和释放。每个线程都会调用ResourcePool实例的use_resource()方法，去获取资源并使用。

最后，在主线程中，我们启动了所有的线程，并等待它们执行完成。

运行上面的代码，可以看到输出的结果如下：

Thread Thread-1 is using resource 10
Thread Thread-2 is using resource 9
Thread Thread-3 is using resource 8
Thread Thread-2 released resource 9
Thread Thread-1 released resource 10
Thread Thread-4 is using resource 10
Thread Thread-3 released resource 8
Thread Thread-5 is using resource 8
Thread Thread-4 released resource 10
Thread Thread-5 released resource 8

从结果可以看出，每次只有3个线程同时访问资源池，其他线程需要等待。当一个线程释放资源后，下一个等待的线程会被唤醒并获得资源，然后使用资源并释放。这样，通过BoundedSemaphore的使用，实现了线程之间的资源共享和同步。