22、信号量(Semaphores,计数信号量,有界信号量,信号量用作锁)

翻译:GentlemanTsao,2020-06-08

文章目录

    • 简单的信号量
  • 使用信号量传递信号
  • 计数信号量
  • 有界信号量
  • 将信号量用作锁

信号量是一种线程同步结构,可用于在线程之间发送信号以避免信号丢失,或像使用锁一样保护临界区。 Java 5在java.util.concurrent包中附带了信号量实现,因此你不必实现自己的信号量。 尽管如此,了解其实现和使用背后的理论还是很有用的。

简单的信号量

如下是一个简单的信号量实现:

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()方法发送一个信号,该信号存储在信号量内部。 release()方法等待信号。 收到信号标志后,将再次将其清除,并退出release()方法。

使用这样的信号量可以避免信号丢失。 用take()代替notify(),以及用release()代替wait()。 如果对take()的调用发生在对release()的调用之前,则调用release()的线程仍会知道take()被调用了,因为信号存储在内部的signal变量中。 使用wait()和notify()不会存储信号。

当使用信号量进行信号传递时,方法名take()和release()似乎有点奇怪。 该名称源于信号量作为锁来使用,如本文后面所述。 在这种情况下,该方法名更有意义。

使用信号量传递信号

如下是一个简化示例,两个线程使用信号量互相发信号:

Semaphore semaphore = new Semaphore();

SendingThread sender = new SendingThread(semaphore);

ReceivingThread receiver = new ReceivingThread(semaphore);

receiver.start();
sender.start();
public class SendingThread {
   
     
  Semaphore semaphore = null;

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

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

    }
  }
}
public class RecevingThread {
   
     
  Semaphore semaphore = null;

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

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

计数信号量

上一节中的Semaphore实现不计算take()方法发送信号的次数。 我们可以更改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--;
  }

}

有界信号量

CoutingSemaphore没有存储信号数量的上限。 我们可以将信号量的实现更改为有上限的,如下所示:

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

请注意,如果信号数量等于上限,则take()方法现在会阻塞。 如果BoundedSemaphore已达到其信号上限,则调用take()的线程不再允许传递其信号,直到某个线程调用release()。

将信号量用作锁

可以将有界信号量用作锁。 为此,请将上限设置为1,并调用take()和release()来保护临界区。 如下是一个例子:

BoundedSemaphore semaphore = new BoundedSemaphore(1);

...

semaphore.take();

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

与使用信号相比,方法take()和release()现在由同一线程调用。 由于只允许一个线程使用信号量,因此所有调用take()的其他线程都将被阻塞,直到调用release()为止。 由于总是先调用take(),因此release()的调用永远不会阻塞。

你还可以使用有界信号量来限制代码段中允许的线程数。 例如,在上面的示例中,如果将BoundedSemaphore的限制设置为5,情况会怎么样呢? 那样的话,一次允许5个线程进入临界区。 但是,你必须确保这5个线程的线程操作不会冲突,否则应用程序将出错。

从finally块内部调用release()方法以确保即使从临界区抛出异常也能被调用到。

下一篇:
2020版Java并发和多线程教程(二十五):阻塞队列

并发系列专栏:
Java并发和多线程教程2020版