多线程之信号量Semaphore及原理

读前必看AQS原理——http://blog.csdn.net/qq_31957747/article/details/74910939

一、信号量（Semaphore）

重入锁ReentrantLock是独占模式，一次都只允许一个线程访问一个资源，而信号量是共享模式，也就是说可以指定多个线程，同时访问某一个资源。

Semaphore的两个构造方法：

public Semaphore(int permits) {        sync = new NonfairSync(permits);    }public Semaphore(int permits, boolean fair) {   //第二个参数指定是否公平        sync = fair ? new FairSync(permits) : new NonfairSync(permits);    }

跟ReentrantLock一样，Semaphore也有公平版本和非公平版本，默认是非公平版本。

在构造信号量对象的时候，必须指定同时有多少线程可以访问某一个资源，也就是参数列表中的permits。

Semaphore的主要方法：

acquire()方法尝试获得一个准入的许可。若无法获得，则线程会等待，直到有线程释放一个许可或者当前线程被中断。

acquireUnterruptibly()跟acquire()方法差不多，不过不响应中断。

tryAcquire()尝试获得许可，如果成功返回true，失败立即返回false，不会等待。

tryAcquire(long timeout,TimeUnit unit)跟tryAcquire()方法差不多，不过失败会等待以timeout为数值，以unit为单位的时间数，超过时间返回false。

release()在线程访问资源结束后，释放一个许可，以使其他等待许可的线程可以进行资源访问。

看个例子：

public class SemapDemo implements Runnable {    final Semaphore semaphore = new Semaphore(5);    @Override    public void run() {        try {            semaphore.acquire();            Thread.sleep(1000);            System.out.println(Thread.currentThread().getId()+" :done!");            semaphore.release();        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static void main(String[] args) {        ExecutorService exec = Executors.newFixedThreadPool(20);        final SemapDemo demo = new SemapDemo();        for(int i =0;i<20;i++){            exec.submit(demo);        }        exec.shutdown();    }}

观察这个程序的输出，你会发现以5个线程一组为单位，依次输出。也就验证了Semaphore是共享模式，接下来我们分析下Semaphore的源码，看看共享是体现在什么地方的。

二、Semahore源码分析：

我们就对acquire()和release()方法进行分析。

2.1 acquire方法

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

2.1.1 acquireSharedInterruptibly方法

public final void acquireSharedInterruptibly(int arg)            throws InterruptedException {        if (Thread.interrupted())            throw new InterruptedException();        if (tryAcquireShared(arg) < 0)       //如果剩余量小于0,这个线程节点就不能访问资源,在等待队列中等着吧；大于0的话，那当然acquire()下面的方法就执行了            doAcquireSharedInterruptibly(arg);    }

2.1.1.1 tryAcquireShared方法在AQS中的定义是要由子类实现，这里我们就看非公平版本的。

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

final int nonfairTryAcquireShared(int acquires) {            for (;;) {                     //自旋                int available = getState();//Semaphore的state就是permits,即还允许访问的资源数,这点跟ReentrantLock不太一样(ReentrantLock的state表示重入数)                int remaining = available - acquires; //还允许访问的资源数-当前线程请求资源数 = 剩余允许允许访问的资源数                if (remaining < 0 ||   //剩余数<0                    compareAndSetState(available, remaining))//剩余数大于0，且自旋的这个周期内资源没有被其他线程访问(CAS自旋保证了原子性,不成功继续自旋)                    return remaining;            }        }

2.1.1.2 doAcquireSharedInterruptibly方法

private void doAcquireSharedInterruptibly(int arg)        throws InterruptedException {        final Node node = addWaiter(Node.SHARED);        boolean failed = true;        try {            for (;;) {                final Node p = node.predecessor();                if (p == head) {                    int r = tryAcquireShared(arg);                    if (r >= 0) {                        setHeadAndPropagate(node, r);                        p.next = null; // help GC                        failed = false;                        return;                    }                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    throw new InterruptedException();            }        } finally {            if (failed)                cancelAcquire(node);        }    }

这个方法在AQS那篇文章分析过，这里就不做多介绍了，就是一个线程进入等待状态，等待被唤醒的过程。

2.2 release方法

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

2.2.1 releaseShared方法

public final boolean releaseShared(int arg) {        if (tryReleaseShared(arg)) {  //尝试释放资源            doReleaseShared();      //唤醒后继资源            return true;        }        return false;    }

doReleaseShared()方法我们在AQS那篇文章中也已经介绍过，所以这边就分析Semaphore中的Sync重写的tryReleaseShared方法。

2.2.1.1 tryReleaseShared方法

protected final boolean tryReleaseShared(int releases) {            for (;;) {         //自旋                int current = getState();                   int next = current + releases; //释放资源后的可访问的资源数                if (next < current)     // 这里应该是整形溢出                    throw new Error("Maximum permit count exceeded");                if (compareAndSetState(current, next))//这个自旋周期内资源没有被其他线程访问,就把state的值设置为next                    return true;            }        }

分析到这，大家应该知道Semaphore的共享是怎么一回事儿了吧(当然把permits设置为1的话，又跟ReentrantLock相像了)。

三、Semaphore模拟实现一个连接池

public class ConnectPool {    private int maxConnectNum;    private List<Connect> pool;    private Semaphore semaphore;    public ConnectPool(int maxConnectNum){        this.maxConnectNum = maxConnectNum;        pool = new ArrayList<>(maxConnectNum);        semaphore = new Semaphore(maxConnectNum);        for(int i = 0;i<maxConnectNum;i++){            pool.add(new Connect(this));        }    }    public void poolAdd(Connect c){        pool.add(c);    }    public void semaphoreRelease(){        semaphore.release();    }    public Connect getConnection() throws InterruptedException {        semaphore.acquire();        Connect c = pool.remove(0);        System.out.println(Thread.currentThread().getId()+":拿到了一个连接"+c);        return c;    }        public static void main(String[] args) {        final ConnectPool pool = new ConnectPool(3);        /**         * 第一个线程占用1个连接3秒         */        new Thread() {            public void run() {                try {                    Connect c = pool.getConnection();                    Thread.sleep(3000);                    c.close();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }.start();        /**         * 开启3个线程请求分配连接         */        for (int i = 0; i < 3; i++) {            new Thread() {                public void run() {                    try {                        Connect c = pool.getConnection();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }.start();        }    }}

public class Connect {    private ConnectPool connectPool;    public Connect(ConnectPool connectPool){        this.connectPool = connectPool;    }    /**     * 释放连接     */    public void close(){        connectPool.poolAdd(this);        System.out.println(Thread.currentThread().getId()+":释放了一个连接"+this);        connectPool.semaphoreRelease();    }}

运行结果：

当然只是模拟而已，跟实际的连接池出入应该很大。