信号量（Semaphore）是一个计数器，用来保护对一个或多个共享资源的访问。
信号量原理
你可以认为信号量是一个可以递增或递减的计数器。你可以初始化一个信号量的值为5，此时这个信号量可最大连续减少5次，直到计数器为0。当计数器为0时，你可以让其递增5次，使得计数器值为5。在我们的例子中，信号量的计数器始终限制在[0~5]之间。
显然，信号量并不仅仅是计数器。当计数器值为0时，它们可以使线程等待，即它们是具有计数器功能的锁。
就多线程而言，当一个线程要访问共享资源（由信号量保护）时，首先，它必须获得信号量。如果信号量的内部计数器大于0时，信号量递减计数器，并允许访问共享资源。否则，如果信号量的计数器为0，则信号量将线程置于休眠状态，直到计数器大于0。计数器中的值为0意味着所有共享资源都被其他线程使用，因此希望使用共享资源的线程必须等到有线程空闲（释放信号量）。
当一个线程完成了共享资源的使用时，它必须释放信号量，以便其他线程能够访问共享资源。该操作增加信号量的内部计数器。
如何使用信号量
PrinterQueue.java
该类表示一个打印机队列，它们控制从3个打印机中选择一个空闲的打印机打印，并在打印过程中加锁。当完成打印任务时，打印机被释放，可用于新的打印任务。
该类有2个方法getPrinter()和releasePrinter() ，分别是负责获取空闲的打印机和释放打印机。另外一个方法printJob() 实际上才是核心工作，获取打印机，执行打印任务，然后释放打印机。
它使用以下2个变量：
semaphore：这个变量跟踪在任何时间点使用打印机的数量。
printerlock：在3个可用的打印机中检查/获取空闲打印机时，锁定打印机池。
class PrinterQueue {
//保存可用打印机的数量
private final Semaphore semaphore;
//当检查/获取空闲打印机时加锁
private final Lock printerLock;
//代表空闲的打印机池
private boolean freePrinters[];
public PrinterQueue() {
semaphore = new Semaphore(3);
freePrinters = new boolean[3];
for (int i = 0; i < 3; i++) {
freePrinters[i] = true;
}
printerLock = new ReentrantLock();
}
public void printJob(Object document) {
try {
//递减信号量计数器，标记一台打印机忙碌
semaphore.acquire();
//获取一台空闲打印机
int assignedPrinter = getPrinter();
//执行打印任务
Long duration = (long) (Math.random() * 10000);
System.out.println(Thread.currentThread().getName()
+ ": Printer " + assignedPrinter
+ " : Printing a Job during " + (duration / 1000)
+ " seconds :: Time - " + new Date());
Thread.sleep(duration);
//打印任务完成; 释放打印机给其他线程.
releasePrinter(assignedPrinter);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.printf("%s: The document has been printed\n", Thread
.currentThread().getName());
//递增信号量计数器
semaphore.release();
}
}
//获取空闲打印机
private int getPrinter() {
int foundPrinter = -1;
try {
//获取锁，使得只有一个线程访问
printerLock.lock();
//检查哪台打印机空闲
for (int i = 0; i < freePrinters.length; i++) {
//找到空闲打印机，标记为忙碌
if (freePrinters[i]) {
foundPrinter = i;
freePrinters[i] = false;
break;
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁，使得其他线程可以检查是否有空闲打印机
printerLock.unlock();
}
return foundPrinter;
}
//释放打印机
private void releasePrinter(int i) {
printerLock.lock();
//标记打印机为空闲
freePrinters[i] = true;
printerLock.unlock();
}
}
PrintingJob.java
该类代表可以提交独立的打印工作给打印机。
class PrintingJob implements Runnable {
private PrinterQueue printerQueue;
public PrintingJob(PrinterQueue printerQueue) {
this.printerQueue = printerQueue;
}
@Override
public void run() {
System.out.printf("%s: Going to print a document\n",
Thread.currentThread().getName());
printerQueue.printJob(new Object());
}
}
测试代码
public class SemaphoreExample {
public static void main(String[] args) {
PrinterQueue printerQueue = new PrinterQueue();
Thread thread[] = new Thread[10];
for (int i = 0; i < 10; i++) {
thread[i] = new Thread(new PrintingJob(printerQueue), "Thread " + i);
}
for (int i = 0; i < 10; i++) {
thread[i].start();
}
}
}
执行结果
Thread 0: Going to print a document
Thread 9: Going to print a document
Thread 8: Going to print a document
Thread 7: Going to print a document
Thread 6: Going to print a document
Thread 5: Going to print a document
Thread 4: Going to print a document
Thread 3: Going to print a document
Thread 2: Going to print a document
Thread 1: Going to print a document
Thread 9: Printer 1 : Printing a Job during 4 seconds :: Time - Sat Aug 12 10:14:39 CST 2017
Thread 0: Printer 0 : Printing a Job during 1 seconds :: Time - Sat Aug 12 10:14:39 CST 2017
Thread 8: Printer 2 : Printing a Job during 2 seconds :: Time - Sat Aug 12 10:14:39 CST 2017
Thread 0: The document has been printed
Thread 7: Printer 0 : Printing a Job during 7 seconds :: Time - Sat Aug 12 10:14:41 CST 2017
Thread 8: The document has been printed
Thread 6: Printer 2 : Printing a Job during 4 seconds :: Time - Sat Aug 12 10:14:41 CST 2017
Thread 9: The document has been printed
Thread 5: Printer 1 : Printing a Job during 1 seconds :: Time - Sat Aug 12 10:14:43 CST 2017
Thread 5: The document has been printed
Thread 4: Printer 1 : Printing a Job during 8 seconds :: Time - Sat Aug 12 10:14:44 CST 2017
Thread 6: The document has been printed
Thread 3: Printer 2 : Printing a Job during 5 seconds :: Time - Sat Aug 12 10:14:46 CST 2017
Thread 7: The document has been printed
Thread 2: Printer 0 : Printing a Job during 2 seconds :: Time - Sat Aug 12 10:14:49 CST 2017
Thread 2: The document has been printed
Thread 1: Printer 0 : Printing a Job during 9 seconds :: Time - Sat Aug 12 10:14:51 CST 2017
Thread 3: The document has been printed
Thread 4: The document has been printed
Thread 1: The document has been printed
何时使用二进制信号量
很明显，二进制信号量的值可以是0或1。这意味着二进制信号量保护对单个共享资源的访问，因此信号量的内部计数器只能接受值1或0。
因此，每当你有保护对多个线程访问单个资源的要求时，就可以使用二进制信号量。
如何使用二进制信号量
为了说明二进制信号量的用法，我们将实现一个打印队列，可以由并发任务来打印它们的作业。此打印队列将受到二进制信号量的保护，因此每次只有一个线程执行打印作业。
PrinterQueue.java
该类表示打印机队列。请注意，我们将值1作为该信号量构造函数的参数传递，因此你正在创建一个二进制信号量。
public class PrinterQueue {
private final Semaphore semaphore;
public PrinterQueue() {
semaphore = new Semaphore(1);
}
public void printJob(Object document) {
try {
semaphore.acquire();
Long duration = (long) (Math.random() * 10000);
System.out.println(Thread.currentThread().getName()
+ ": PrintQueue: Printing a Job during " + (duration / 1000)
+ " seconds :: Time - " + new Date());
Thread.sleep(duration);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.printf("%s: The document has been printed\n",
Thread.currentThread().getName());
semaphore.release();
}
}
}
执行结果
Thread 0: Going to print a document
Thread 9: Going to print a document
Thread 8: Going to print a document
Thread 7: Going to print a document
Thread 6: Going to print a document
Thread 5: Going to print a document
Thread 4: Going to print a document
Thread 3: Going to print a document
Thread 2: Going to print a document
Thread 1: Going to print a document
Thread 0: PrintQueue: Printing a Job during 7 seconds :: Time - Sat Aug 12 09:14:23 CST 2017
Thread 0: The document has been printed
Thread 9: PrintQueue: Printing a Job during 5 seconds :: Time - Sat Aug 12 09:14:30 CST 2017
Thread 9: The document has been printed
Thread 8: PrintQueue: Printing a Job during 6 seconds :: Time - Sat Aug 12 09:14:35 CST 2017
Thread 8: The document has been printed
Thread 7: PrintQueue: Printing a Job during 8 seconds :: Time - Sat Aug 12 09:14:42 CST 2017
Thread 7: The document has been printed
Thread 6: PrintQueue: Printing a Job during 0 seconds :: Time - Sat Aug 12 09:14:50 CST 2017
Thread 6: The document has been printed
Thread 5: PrintQueue: Printing a Job during 4 seconds :: Time - Sat Aug 12 09:14:51 CST 2017
Thread 5: The document has been printed
Thread 4: PrintQueue: Printing a Job during 6 seconds :: Time - Sat Aug 12 09:14:55 CST 2017
Thread 4: The document has been printed
Thread 3: PrintQueue: Printing a Job during 0 seconds :: Time - Sat Aug 12 09:15:01 CST 2017
Thread 3: The document has been printed
Thread 2: PrintQueue: Printing a Job during 3 seconds :: Time - Sat Aug 12 09:15:02 CST 2017
Thread 2: The document has been printed
Thread 1: PrintQueue: Printing a Job during 4 seconds :: Time - Sat Aug 12 09:15:05 CST 2017
Thread 1: The document has been printed
参考
1.Binary Semaphore Tutorial and Example
2.Control concurrent access to multiple copies of a resource using Semaphore
