Semaphore源码

1 概述

1.1 简介

信号量为多线程协作提供了更强大的控制方法。广义上说，信号量是对锁的扩展。synchronized和ReentrantLock一次都只允许一个线程访问一个资源，而信号量可以指定多个线程同时访问某一个资源。

public Semaphore(int permits) // 指定信号量的准入数
public Semaphore(int permits, boolean fair) // 同时指定是否公平

public void acquire() throws InterruptedException
public void acquire(int permits) throws InterruptedException
public void release()
public void release(int permits)

1.2 特性

Semaphore通常用于限制同一时间对共享资源的访问次数上，也就是常说的限流。

例如

public class SemaDemo implements Runnable {
    final Semaphore semp = new Semaphore(5);

    @Override
    public void run() {
        try {
            semp.acquire();
            Thread.sleep(2000);
            System.out.println("Thread-" + Thread.currentThread().getId() + ":done!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semp.release();
        }
    }

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(20);
        final SemaDemo demo = new SemaDemo();
        for (int i = 0; i < 20; i++) {
            exec.submit(demo);
        }
        exec.shutdown();
    }
}

1.3 使用

例如：LeetCode 1188. 设计有限阻塞队列

实现一个拥有如下方法的线程安全有限阻塞队列：

BoundedBlockingQueue(int capacity) 构造方法初始化队列，其中capacity代表队列长度上限。

• void enqueue(int element) 在队首增加一个element. 如果队列满，调用线程被阻塞直到队列非满。
• int dequeue() 返回队尾元素并从队列中将其删除. 如果队列为空，调用线程被阻塞直到队列非空。
• int size() 返回当前队列元素个数。

你的实现将会被多线程同时访问进行测试。每一个线程要么是一个只调用enqueue方法的生产者线程，要么是一个只调用dequeue方法的消费者线程。size方法将会在每一个测试用例之后进行调用。

class BoundedBlockingQueue {

    private Semaphore add;
    private Semaphore remove;

    private Queue<Integer> queue;

    public BoundedBlockingQueue(int capacity) {
        this.add = new Semaphore(capacity);
        this.remove = new Semaphore(0);
        this.queue = new LinkedList();
    }
    
    public void enqueue(int element) throws InterruptedException {
        add.acquire();
        queue.add(element);
        remove.release();
    }
    
    public int dequeue() throws InterruptedException {
        remove.acquire();
        int res = queue.poll();
        add.release();
        return res;
    }
    
    public int size() {
        return queue.size();
    }
}

例如：LeetCode 1116. 打印零与奇偶数

假设有这么一个类：

class ZeroEvenOdd {
public ZeroEvenOdd(int n) { … } // 构造函数
public void zero(printNumber) { … } // 仅打印出 0
public void even(printNumber) { … } // 仅打印出 偶数
public void odd(printNumber) { … } // 仅打印出 奇数
}
相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：

线程 A 将调用 zero()，它只输出 0 。
线程 B 将调用 even()，它只输出偶数。
线程 C 将调用 odd()，它只输出奇数。
每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506… ，其中序列的长度必须为 2n。

示例 1：

输入：n = 2
输出：“0102”
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 “0102”。

示例 2：

输入：n = 5
输出：“0102030405”

class ZeroEvenOdd {
    private int n;

    private Semaphore zero = new Semaphore(1);
    private Semaphore even = new Semaphore(0);
    private Semaphore old = new Semaphore(0);

    
    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            zero.acquire();
            printNumber.accept(0);
            if(i % 2 == 0){
                even.release();
            }else{
                old.release();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i <= n; i++) {
            if(i % 2 == 0){
                even.acquire();
                printNumber.accept(i);
                zero.release();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if(i % 2 == 1){
                old.acquire();
                printNumber.accept(i);
                zero.release();
            }
        }
    }
}

2 源码

2.1 类结构

Semaphore中包含了一个实现了AQS的同步器Sync，以及它的两个子类FairSync和NonFairSync，这说明Semaphore也是区分公平模式和非公平模式的。

2.2 源码分析

2.2.1 构造

创建Semaphore时需要传入许可次数，许可次数在之后可动态调整，即通过release(int permits)。

Semaphore默认是非公平模式，但是你可以调用第二个构造方法声明其为公平模式。

// 构造方法，创建时要传入许可次数，默认使用非公平模式
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}
// 构造方法，需要传入许可次数，及是否公平模式
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

2.2.2 内部类Sync

// java.util.concurrent.Semaphore.Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;
	
	// 构造方法，传入许可次数，放入state中
    Sync(int permits) {
        setState(permits);
    }

	// 获取许可次数
    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的值成功，就说明释放许可成功，则返回true
            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");
            // 原子更新state的值，成功了返回true
            if (compareAndSetState(current, next))
                return;
        }
    }

	// 销毁许可
    final int drainPermits() {
        for (;;) {
        	// 看看还有几个许可
            int current = getState();
            // 如果为0，直接返回
            // 如果不为0，把state原子更新为0
            if (current == 0 || compareAndSetState(current, 0))
                return current;
        }
    }
}

小结：

1. 许可是在构造方法时传入的；
2. 许可存放在状态变量state中；
3. 尝试获取一个许可的时候，则state的值减1；
4. 当state的值为0的时候，则无法再获取许可；
5. 释放一个许可的时候，则state的值加1；
6. 许可的个数可以动态改变；

2.2.3 内部类NonfairSync

非公平模式下，直接调用父类的nonfairTryAcquireShared()尝试获取许可（Sync实现即是非公平）。

// java.util.concurrent.Semaphore.NonfairSync
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;
    // 构造方法，调用父类的构造方法
    NonfairSync(int permits) {
        super(permits);
    }
    // 尝试获取许可，调用父类的nonfairTryAcquireShared()方法
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

2.2.4 内部类FairSync

// java.util.concurrent.Semaphore.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;
            // 没有排队的再尝试更新state的值
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

公平模式下，先检测前面是否有排队的，如果有排队的则获取许可失败，进入队列排队，否则尝试原子更新state的值。

2.2.5 Semaphore其他API

acquire()方法
获取一个许可，默认使用的是可中断方式，如果尝试获取许可失败，会进入AQS的队列中排队。

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

acquire(int permits)方法

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

release()方法
释放一个许可，释放一个许可时state的值会加1，并且会唤醒下一个等待获取许可的线程。

public void release() {
    sync.releaseShared(1);
}

release(int permits)方法
一次释放多个许可，state的值会相应增加permits的数量。

public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

参考

死磕 java同步系列之Semaphore源码解析