Java并发编程--深入理解Semaphore

Semaphore简介

Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。

Semaphore的用途

Semaphore可以用于做流量控制，特别公用资源有限的应用场景，比如数据库连接。假如有一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发的读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有10个，这时我们必须控制只有十个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候，我们就可以使用Semaphore来做流控。

自定义简单Semaphore类

下面是一个自定义的简单semaphore类。

public class Semaphore {
  private boolean signal = false;

  public synchronized void take() {
    this.signal = true;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(!this.signal) wait();
    this.signal = false;
  }

}

上面的take()方法相当于Object中的notify()方法，用于发送一个信号量，而release()方法相当于Object中的wait()方法，用于接收一个信号量，因此可以用Semaphore类来代替Object的notify()和wait()。

---

下面是两个进程通过semaphore类通信的实例。

public class SemaphoreTest{

    public static void main(String args[])
    {
        Semaphore semaphore = new Semaphore();

        SendingThread sender = new SendingThread(semaphore);

        ReceivingThread receiver = new ReceivingThread(semaphore);

        receiver.start();

        sender.start();
    }
}

//@1 SendingThread

public class SendingThread extends Thread{
  Semaphore semaphore = null;

  public SendingThread(Semaphore semaphore){
    this.semaphore = semaphore;
  }

  public void run(){
    while(true){
      //do something, then signal
      this.semaphore.take();

    }
  }
}

//@2 RecevingThread
public class RecevingThread extends Thread{
  Semaphore semaphore = null;

  public ReceivingThread(Semaphore semaphore){
    this.semaphore = semaphore;
  }

  public void run(){
    while(true){
      this.semaphore.release();
      //receive signal, then do something...
    }
  }
}

Counting Semaphore

前面实现的简单Semaphore类没有计算take()方法中signals的数量， 下面实现计算signal数量的Semaphore的类，叫做 Counting Semaphore。

public class CountingSemaphore {
  private int signals = 0;

  public synchronized void take() {
    this.signals++;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(this.signals == 0) wait();
    this.signals--;
  }

}

Bounded Semaphore

Bounded Semaphore用来限制signal的个数，类似于队列的数量。

public class BoundedSemaphore {
  private int signals = 0;
  private int bound   = 0;

  public BoundedSemaphore(int upperBound){
    this.bound = upperBound;
  }

  public synchronized void take() throws InterruptedException{
    while(this.signals == bound) wait();
    this.signals++;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(this.signals == 0) wait();
    this.signals--;
    this.notify();
  }
}

用Semaphores 实现 Locks

BoundedSemaphore semaphore = new BoundedSemaphore(1);

...

semaphore.take();

try{
  //critical section
} finally {
  semaphore.release();
}

参考文献

http://tutorials.jenkov.com/java-concurrency/semaphores.html