Java并发编程-同步辅助类之Semaphore

信号量Semaphore是一个计数信号量，用来保护一个或多个共享资源的访问，是Java Concurrent包下提供的另一种同步方式：使用加锁方式同步，一个时间只能有一个线程访问共享资源，而使用Senmaphore可以控制多个线程同时访问共享资源。

Semaphore信号量

Semaphore可以控制某个资源可被同时访问的个数（通过构造方法设置）：

- 通过 acquire() 获取一个许可，如果没有就等待。 
- release() 释放一个许可。

比如在Windows下可以设置共享文件的最大客户端访问个数。 Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会（和lock类似可以设置为公平模式），这取决于构造Semaphore对象时传入的参数选项。

单个信号量（二进制信号量，计数只有0和1）的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。

下面代码参考Java并发编程实践，利用Semaphore控制使能够有两个线程同一时段访问共享数据。

package MyThread;

import java.util.Date;
import java.util.concurrent.Semaphore;

//打印任务队列，共享数据
class PrintQueue{
    private Semaphore semaphore;
    PrintQueue(int num){
        semaphore=new Semaphore(num);
    }
    public void printJob(){
        try {
            //获取
            semaphore.acquire();
            System.out.printf("%s printJob  time %s \n",Thread.currentThread().getName(),new Date());
            Thread.sleep(3000);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            //释放
            semaphore.release();
        }
    }
}
//模拟打印机
class PrintMachine implements Runnable{
    private PrintQueue printQueue;
    PrintMachine(PrintQueue printQueue){
        this.printQueue=printQueue;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        printQueue.printJob();
    }

}
public class MySemaphoreTest {
    public static void main(String[] arg){
        PrintQueue printQueue=new PrintQueue(2);
        //创建5个线程访问共享数据
        for(int i=0;i<5;i++){
            new Thread(new PrintMachine(printQueue)).start();
        }
    }
}

• 结果，可以看出同一时段可以有两个线程同时访问共享数据。 
  Thread-1 printJob time Mon Jun 06 15:55:42 CST 2016 
  Thread-0 printJob time Mon Jun 06 15:55:42 CST 2016 
  Thread-2 printJob time Mon Jun 06 15:55:45 CST 2016 
  Thread-3 printJob time Mon Jun 06 15:55:45 CST 2016 
• Thread-4 printJob time Mon Jun 06 15:55:48 CST 2016 

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

1 2 3 4 5 6

public Semaphore( int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问      sync = new NonfairSync(permits); } public Semaphore( int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可      sync = (fair)? new FairSync(permits) : new NonfairSync(permits); }

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

1 2 3 4

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个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

1 2 3 4

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

另外还可以通过availablePermits()方法得到可用的许可数目。

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

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 2

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();              }          }      } }

执行结果：

1 2 3 4 5 6 7 8 9 10 11 12 1

工人 0 占用一个机器在生产... 工人 1 占用一个机器在生产... 工人 2 占用一个机器在生产... 工人 4 占用一个机器在生产... 工人 5 占用一个机器在生产... 工人 0 释放出机器 工人 2 释放出机器 工人 3 占用一个机器在生产... 工人 7 占用一个机器在生产... 工人 4 释放出机器 工人 5 释放出机器 工人 1 释放出机器 工人 6 占用一个机器在生产... 工人 3 释放出机器 工人 7 释放出机器 工人 6 释放出机器

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

1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

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

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

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