java.util.concurrent系列之--Semaphore

1、Semaphore用法

Semaphore ['seməfɔː] 信号

Semaphore翻译成字面意思为 信号量，Semaphore能够控同时访问的线程个数，经过 acquire() 获取一个许可，若是没有就等待，而 release() 释放一个许可。

2、Semaphore 方法讲解

Semaphore类位于java.util.concurrent包下，它提供了2个构造器：

//参数permits表示许可数目，即同时能够容许多少线程进行访问
public Semaphore(int permits) {          
    sync = new NonfairSync(permits);
}

//这个多了一个参数fair表示是不是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {    
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

下面说一下Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()用来获取一个许可，若无许可可以得到，则会一直等待，直到得到许可。

release()用来释放许可。注意，在释放许可以前，必须先获得到许可。

这4个方法都会被阻塞，若是想当即获得执行结果，可使用下面几个方法：

//尝试获取一个许可，若获取成功，则当即返回true，若获取失败，则当即返回false
public boolean tryAcquire() { };   

//尝试获取一个许可，若在指定的时间内获取成功，则当即返回true，不然则当即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  

 //尝试获取permits个许可，若获取成功，则当即返回true，若获取失败，则当即返回false
public boolean tryAcquire(int permits) { };

//尝试获取permits个许可，若在指定的时间内获取成功，则当即返回true，不然则当即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { };

另外还能够经过availablePermits()方法获得可用的许可数目。

2、下面经过一个例子来看一下Semaphore的具体使用：

倘若一个工厂有5台机器，可是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其余工人才

能继续使用。那么咱们就能够经过Semaphore来实现：

public class Test {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
 
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }
 
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果：

3、下面对上面说的三个辅助类进行一个总结：

1）CountDownLatch和CyclicBarrier都可以实现线程之间的等待，只不过它们侧重点不一样：

CountDownLatch通常用于某个线程A等待若干个其余线程执行完任务以后，它才执行；

而CyclicBarrier通常用于一组线程互相等待至某个状态，而后这一组线程再同时执行；

另外，CountDownLatch是不可以重用的，而CyclicBarrier是能够重用的。

2）Semaphore其实和锁有点相似，它通常用于控制对某组资源的访问权限。

4、参考文章

http://www.importnew.com/21889.html