java-并发-AQS应用之Semaphore

介绍

本质：类似资源池，池中有n个资源，获取资源时如果不够则等待，释放资源时唤醒等待的线程

原理：

构造函数入参permits，表示资源个数。

获取资源 acquire() 时，如果permits==0则等待，被唤醒后执行 permits = permits-1。

释放资源 release() 时，执行 permits = permits + 1，唤醒其他线程。

使用DEMO

实现生产者-消费者模型：

class Pool {
    private final Semaphore semaphore;
    private final Deque<String> deque = new LinkedList<>();

    public Pool(int n) {
        semaphore = new Semaphore(n);
    }

    public String get() {
        String s = deque.pollFirst();
        semaphore.release();
        return s;
    }

    public void put(String s) throws InterruptedException {
        semaphore.acquire();
        deque.offerLast(s);
    }
}

自己实现

public class MySemaphore {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final int semCount;
    private int curCount;

    public MySemaphore(int semCount) {
        this.semCount = semCount;
    }

    public void acquire() {
        lock.lock();
        try {
            curCount++;
            if (curCount > semCount) {
                condition.await();
            }
        } catch (Exception ignored) {
        } finally {
            lock.unlock();
        }
    }

    public void release() {
        lock.lock();
        try {
            curCount--;
            condition.signal();
        } catch (Exception ignored) {
        } finally {
            lock.unlock();
        }
    }
}