JUC学习（一）：Semaphore信号量

目录

一.简介

二.构造方法

三.acquire系列方法

四.release方法

五.其它方法

5.1 availablePermits & drainPermits

5.2 reducePermits

5.3 isFair

5.4 hasQueuedThreads & getQueuedThreads & getQueueLength

六.生产者-消费者问题

---

一.简介

Semaphore的主要作用就是限制线程并发的数量。并发数与效率大致是个正态分布，在到达并发数阈值之前，并发量越大，效率越高，但是随着并发量不断增加，单个线程持有CPU的时间必然减少，同时线程间上下文切换也要消耗非常可观的时间，导致效率反而越来越差，因此限制并发数还是很有必要的。

首先用一个例子来看信号量的使用，这里将信号量的许可数设置为1：

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    private static Semaphore semaphore = new Semaphore(1);

    public static void main(String args[]) {
        Thread A=new Thread(new Service(),"A");
        Thread B=new Thread(new Service(),"B");
        Thread C=new Thread(new Service(),"C");
        A.start();
        B.start();
        C.start();
    }

    private static class Service implements Runnable{

        @Override
        public void run() {
            try{
                semaphore.acquire();
                System.out.println("线程"+Thread.currentThread().getName()+"模拟耗时操作。。。当前时间："+System.currentTimeMillis());
                Thread.sleep(2000L);
                System.out.println("线程"+Thread.currentThread().getName()+"耗时操作完成,当前时间："+System.currentTimeMillis());
                semaphore.release();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

运行后，输出如下：

线程A模拟耗时操作。。。当前时间：1550817220368
线程A耗时操作完成,当前时间：1550817222370
线程B模拟耗时操作。。。当前时间：1550817222370
线程B耗时操作完成,当前时间：1550817224371
线程C模拟耗时操作。。。当前时间：1550817224371
线程C耗时操作完成,当前时间：1550817226371

可以看到，三个线程按照顺序同步运行，并且在前一批线程运行完毕后，后一批线程才会开始运行。运行的效果和使用了synchronized关键字类似。

根据线程的性质，我们可以很容易的估计到，如果不设置信号量，那么示例中三个线程将会同时乱序执行。假如信号量的许可数大于1，那么同一批线程之间都是乱序执行的，不同批线程之间则同步执行。

二.构造方法

Semaphore的构造方法一共有两个版本：

    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

主要工作就是实例化sync对象，默认实例化为非公平版本。

sync是一个Sync类型的类成员对象，Sync是Semaphore的内部类。从Semaphore构造函数的代码中可以看到，FairSync和NonFairSync都是Sync的子类。

Sync类继承了AbstractQueuedSynchronizer，也就是著名的AQS。Sync的构造方法如下：

Sync(int permits) {
    setState(permits);
}

所以，Semaphore实例化的实质就是创建一个AQS对象，并为它设置state。

三.acquire系列方法

acquire系列方法是Semaphore的核心方法，作用是获取许可，有两个版本，另外还有两个不可中断的acquireUninterruptibly方法：

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

    //不可中断版本
    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }
    public void acquireUninterruptibly(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireShared(permits);
    }

无参版本默认获取1个许可。可以看到，acquire实际上调用了sync的acquireSharedInterruptibly（非中断版本则是acquireShared，以下提到的方法，只要带Interruptibly后缀，就一定有非中断版本，不再重复提及了）方