使用

信号量（Semaphore）允许多个线程同时访问临界区资源，而 ReentrantLock 这类锁同时只允许一个线程访问临界区资源。

Semaphore 就是共享锁，它的构造方法可以传一个许可数 permits，表示临界区资源数量，多少个资源同时也最多只能由多少个线程来访问。当 permits 等于 1 时，Semaphore 就等价于 ReentrantLock 这类互斥锁。

代码示例：

@Test
public void test() throws InterruptedException {
    // 定义一个线程池
    ExecutorService executor = Executors.newFixedThreadPool(3);
    int userNuber = 10;
    CountDownLatch countDownLatch = new CountDownLatch(userNuber);
    // 三个许可，表示资源总数，这里表示只有三本书籍，所以最多只能由三个人借阅，即最多只能有三个线程获取到锁
    int permits = 3;
    Semaphore semaphore = new Semaphore(permits);

    IntStream.range(0, userNuber).forEach(i -> {
        executor.submit(() -> {
            try {
                System.out.println("学生" + i + "等待借阅书籍......");

                // 获取一个许可（加锁）
                semaphore.acquire(1);

                System.out.println("学生" + i + "借阅到了一个本书籍，当前还剩余" + semaphore.availablePermits() + "本书籍");
                Thread.sleep(i * 500);

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 释放一个许可（解锁）
                semaphore.release(1);
                System.out.println("学生" + i + "归还了一个本书籍，当前还剩余" + semaphore.availablePermits() + "本书籍");
                countDownLatch.countDown();
            }
        });
    });

    countDownLatch.await();
    executor.shutdown();

    /**
         * 执行结果：
         *
         * 学生0等待借阅书籍......
         * 学生0借阅到了一个本书籍，当前还剩余2本书籍
         * 学生1等待借阅书籍......
         * 学生1借阅到了一个本书籍，当前还剩余1本书籍
         * 学生2等待借阅书籍......
         * 学生2借阅到了一个本书籍，当前还剩余0本书籍
         * 学生0归还了一个本书籍，当前还剩余1本书籍
         * 学生3等待借阅书籍......
         * 学生3借阅到了一个本书籍，当前还剩余0本书籍
         * 学生1归还了一个本书籍，当前还剩余1本书籍
         * 学生4等待借阅书籍......
         * 学生4借阅到了一个本书籍，当前还剩余0本书籍
         * 学生2归还了一个本书籍，当前还剩余1本书籍
         * 学生5等待借阅书籍......
         * 学生5借阅到了一个本书籍，当前还剩余0本书籍
         * 学生3归还了一个本书籍，当前还剩余1本书籍
         * 学生6等待借阅书籍......
         * 学生6借阅到了一个本书籍，当前还剩余0本书籍
         * 学生4归还了一个本书籍，当前还剩余1本书籍
         * 学生7等待借阅书籍......
         * 学生7借阅到了一个本书籍，当前还剩余0本书籍
         * 学生5归还了一个本书籍，当前还剩余1本书籍
         * 学生8等待借阅书籍......
         * 学生8借阅到了一个本书籍，当前还剩余0本书籍
         * 学生6归还了一个本书籍，当前还剩余1本书籍
         * 学生9等待借阅书籍......
         * 学生9借阅到了一个本书籍，当前还剩余0本书籍
         * 学生7归还了一个本书籍，当前还剩余1本书籍
         * 学生8归还了一个本书籍，当前还剩余2本书籍
         * 学生9归还了一个本书籍，当前还剩余3本书籍
         */
}

源码解析

Sync 内部类

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;

    // Semaphore 构造函数的传参 permits 赋值给 state
    Sync(int permits) {
        setState(permits);
    }

    // 获取许可数（即 state 的值）
    final int getPermits() {
        return getState();
    }

    // 非公平锁方式获取共享锁
    final int nonfairTryAcquireShared(int acquires) {
        for (;;) {
            // 当前可用的许可数
            int available = getState();
            // 当前申请锁后剩余的许可数
            int remaining = available - acquires;
            // 如果剩余许可数小于 0 直接返回剩余许可数
            // 如果剩余许可数大于 0，将其设置为 state，如果成功，则返回剩余许可数
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }

    // 释放锁
    protected final boolean tryReleaseShared(int releases) {
        for (;;) {
            // 当前可用的许可数
            int current = getState();
            // （释放锁后）增加许可数
            int next = current + releases;
            if (next < current) // overflow
                throw new Error("Maximum permit count exceeded");
            // 将增加后的许可数赋值给 state，成功则返回，否则自旋重试
            if (compareAndSetState(current, next))
                return true;
        }
    }

    // 减少许可数
    final void reducePermits(int reductions) {
        for (;;) {
            int current = getState();
            int next = current - reductions;
            if (next > current) // underflow
                throw new Error("Permit count underflow");
            if (compareAndSetState(current, next))
                return;
        }
    }

    // 清空许可数
    final int drainPermits() {
        for (;;) {
            // 当前许可数
            int current = getState();
            // 将 state 设置为 0
            if (current == 0 || compareAndSetState(current, 0))
                // 返回当前许可数
                return current;
        }
    }
}

NonfairSync 内部类

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;

    NonfairSync(int permits) {
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

FairSync 内部类

static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;

    FairSync(int permits) {
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
        for (;;) {
            // 如果当前线程节点还有前序节点，则获取锁失败
            if (hasQueuedPredecessors())
                return -1;
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

构造函数

// 默认使用非公平锁
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

// permits 表示同时允许访问临界区资源的线程数
// fair 表示使用公平锁实现还是非公平锁实现
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

acquire

// 可中断地阻塞获取锁
public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

acquireUninterruptibly

// 不可中断地阻塞获取锁
public void acquireUninterruptibly() {
    sync.acquireShared(1);
}

tryAcquire

public boolean tryAcquire() {
    // nonfairTryAcquireShared 返回剩余可用许可数
    // 剩余可用许可数大于等于 0，表示可以获取锁
    return sync.nonfairTryAcquireShared(1) >= 0;
}

public boolean tryAcquire(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

release

// 释放锁（一个许可）
public void release() {
    sync.releaseShared(1);
}

acquire

// 一次获取 permits 个许可（可中断，阻塞获取）
public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

acquireUninterruptibly

// 一次获取 permits 个许可（不可中断、阻塞获取）
public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

tryAcquire

// 一次获取 permits 个许可（可中断，非阻塞获取）
public boolean tryAcquire(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
}

// 一次获取 permits 个许可（可中断，非阻塞获取、超时可退出）
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
    throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

release

// 释放多个许可
public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}