Semaphore源码解析（基于JDK8）

1 介绍

Semaphore 称为信号量，也是一个共享锁。通过一个内部类 Sync 继承 AQS，并重写了 tryAcquireShared和 tryReleaseShared。共享锁具体原理可以见我 AQS 的第二篇。AQS(二)共享锁

必须给初始的资源个数 state。每次 acquire 都会减少 state，如果为 0，会堵塞；release 增加 state。

就好比一个厕所管理员，站在门口，只有厕所有空位，就开门允许与空侧数量等量的人进入厕所。多个人进入厕所后，相当于N个人来分配使用N个空位。为避免多个人来同时竞争同一个侧卫，在内部仍然使用锁来控制资源的同步访问。

简单使用如下。

Semaphore semaphore = new Semaphore(10,true);//初始有10个资源，true 表示公平锁
semaphore.acquire();//获取，暂时获取不到会堵塞
semaphore.release();//释放

如果资源只有一个，类似于 ReentrantLock，但和 ReentrantLock 也有区别。具体在于 ReentrantLock 总是可重入的，可以重入若干次；而 Semaphore 并不区分是当前线程重入获取资源还是其他线程获取资源，所以重入也会减少 state，state 为 1 的话，说明不可重入。

在实现 AQS 的方法方面，共享锁实现需要自旋，而独占锁不需要。

2 tryAcquireShared

对于公平锁和非公平锁该方法的实现是不同的，公平锁会先看一下队列中是否有等待的线程，是的话则失败，否则不断自旋，只要资源够，就能成功；非公平锁每次不会看前面是否有线程，而是直接抢。

// FairSync
protected int tryAcquireShared(int acquires) {
            for (;;) {
              	//公平锁在队列中不能有前面的节点，否则失败
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
              	// 有两种情况会返回，一种是资源不够，另一种是 CAS 成功了。
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }


// NonfairSync
protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
	//  Sync
final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
              	// 有两种情况会返回，一种是资源不够，另一种是 CAS 成功了。
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

3 tryReleaseShared

在不溢出的情况下，不断自旋执行 CAS，直到某次成功后返回 true。

protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
              	// 如果 releases 总是正的，出现下面的情况只可能是溢出
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }

4 构造器和其他

// Semaphore
// 默认非公平锁
public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
// 第二个参数表示是否是公平锁。    
public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

// Sync 
// 自旋清空资源，并返回清空前的值
final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
// 和 tryAcquireShared 的区别是 next 可以为负数 
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;
            }
        }

5 使用

5.1 简单使用

下面这个例子中，资源只有两个，有10个线程，每个线程获取后会暂停5s然后释放，查看结果。

import java.util.concurrent.Semaphore;

public class B {
    public static Semaphore semaphore = null;
    public static void main(String[] args) throws Exception{
        semaphore = new Semaphore(2,true);
        Thread[] threads = new Thread[10];
        for(int i=0;i<threads.length;i++){
            threads[i] = new MyThread(semaphore,"线程"+i);
            threads[i].start();
        }
    }
}

class MyThread extends Thread{
    private Semaphore semaphore = null;
    public MyThread(Semaphore semaphore,String name){
        super(name);
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println(getName()+"已获取资源");
            Thread.sleep(5000);
        } catch(Exception e){
            e.printStackTrace();
        }finally {
            semaphore.release();
            System.out.println(getName()+"已释放资源");
        }
    }
}

5.2 尝试可重入

由于重入也会使用资源，所以在只有一个资源的情况下，重入是不可能的。

import java.util.concurrent.Semaphore;

public class C {
    public static Semaphore semaphore = null;
    public static void main(String[] args) throws Exception{
        semaphore = new Semaphore(1,true);
        Thread thread = new MyThread2(semaphore);
        thread.start();

    }
}

class MyThread2 extends Thread{
    private Semaphore semaphore = null;
    public MyThread2(Semaphore semaphore){
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();
            enter();
        } catch(Exception e){
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
    }

    public void enter() {
        try {
          	// 会被堵塞在这一步，无法继续
            semaphore.acquire();
            System.out.println("可以重入");
        } catch(Exception e){
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
    }
}

5.3 直接释放

对于 Semaphore 来说，可以不执行 acquire 直接执行 release，就如下面的 testSemaphore，结果是 3.

对于 ReentrantLock，这显然不可能，必须先持有锁，才能释放。如果直接释放，testReentrantLock 会抛出 java.lang.IllegalMonitorStateException。

import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class C {
    public static void main(String[] args) throws Exception{
        testReentrantLock();
        //testSemaphore();
    }
  	//没有异常，结果是3
    public static void testSemaphore(){
        Semaphore semaphore = new Semaphore(1,true);
        semaphore.release();
        semaphore.release();
        System.out.println(semaphore.availablePermits());
    }
  	//会抛出 java.lang.IllegalMonitorStateException
    public static void testReentrantLock(){
        ReentrantLock rt = new ReentrantLock();
        rt.unlock();
    }
}