Java中如何用Semaphore限制资源访问

import java.util.concurrent.Semaphore;

public class ResourcePool {

    private final Semaphore semaphore;
    private final Object[] resources;
    private final boolean[] used;

    public ResourcePool(int poolSize) {
        this.semaphore = new Semaphore(poolSize);
        this.resources = new Object[poolSize];
        this.used = new boolean[poolSize];

        for (int i = 0; i < poolSize; i++) {
            resources[i] = new Object(); // 假设资源是Object
            used[i] = false;
        }
    }

    public Object acquire() throws InterruptedException {
        semaphore.acquire(); // 请求一个许可，如果许可不可用，则阻塞
        return getResource();
    }

    public void release(Object resource) {
        if (returnResource(resource)) {
            semaphore.release(); // 释放一个许可
        }
    }

    private synchronized Object getResource() {
        for (int i = 0; i < resources.length; i++) {
            if (!used[i]) {
                used[i] = true;
                return resources[i];
            }
        }
        return null; // 不应该发生
    }

    private synchronized boolean returnResource(Object resource) {
        for (int i = 0; i < resources.length; i++) {
            if (resources[i] == resource) {
                if (used[i]) {
                    used[i] = false;
                    return true;
                } else {
                    // 资源已经被释放
                    return false;
                }
            }
        }
        return false; // 资源不在池中
    }

    public static void main(String[] args) throws InterruptedException {
        ResourcePool pool = new ResourcePool(3);

        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                try {
                    Object resource = pool.acquire();
                    System.out.println("Thread " + threadId + " acquired resource: " + resource);
                    Thread.sleep((long) (Math.random() * 1000)); // 模拟使用资源
                    pool.release(resource);
                    System.out.println("Thread " + threadId + " released resource: " + resource);

                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }

        Thread.sleep(5000); // 等待一段时间让线程完成
    }
}