Semaphore信号灯控制线程

来源：https://blog.csdn.net/carson0408/article/details/79475723

 

Semaphore是一种在多线程环境下使用的设施，该设施负责协调各个线程，以保证它们能够正确、合理的使用公共资源的设施，也是操作系统中用于控制进程同步互斥的量。Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于给线程规定一个量从而控制允许活动的线程数。

 

1.工作原理

 

        以一个停车场是运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开两辆，则又可以放入两辆，如此往复。这个停车系统中，每辆车就好比一个线程，看门人就好比一个信号量，看门人限制了可以活动的线程。假如里面依然是三个车位，但是看门人改变了规则，要求每次只能停两辆车，那么一开始进入两辆车，后面得等到有车离开才能有车进入，但是得保证最多停两辆车。对于Semaphore类而言，就如同一个看门人，限制了可活动的线程数。

 

Semaphore主要方法：

 

Semaphore(int permits):构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。

 

Semaphore(int permits,boolean fair):构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。

 

void acquire():从此信号量获取一个许可前线程将一直阻塞。相当于一辆车占了一个车位。

 

void acquire(int n):从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。比如n=2，就相当于一辆车占了两个车位。

 

void release():释放一个许可，将其返回给信号量。就如同车开走返回一个车位。

 

void release(int n):释放n个许可。

 

int availablePermits()：当前可用的许可数。

 

2.实例讲解

 

        接下来举个例子，就是关于每个人的个人信息，那么一个人占用一个线程，并用Semphore类创建对象从而初始化信号量，控制可活动的线程数。具体代码如下：

 

package concurrent;

import java.util.concurrent.Semaphore;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.LinkedBlockingQueue;

public class SemaphoreDemo {

private static final Semaphore semaphore=new Semaphore(3);

private static final ThreadPoolExecutor threadPool=new ThreadPoolExecutor(5,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());

 

private static class InformationThread extends Thread{

private final String name;

private final int age;

public InformationThread(String name,int age)

{

this.name=name;

this.age=age;

}

 

public void run()

{

try

{

semaphore.acquire();

System.out.println(Thread.currentThread().getName()+":大家好，我是"+name+"我今年"+age+"岁当前时间为："+System.currentTimeMillis());

Thread.sleep(1000);

System.out.println(name+"要准备释放许可证了，当前时间为："+System.currentTimeMillis());

System.out.println("当前可使用的许可数为："+semaphore.availablePermits());

semaphore.release();

 

}

catch(InterruptedException e)

{

e.printStackTrace();

}

}

}

public static void main(String[] args)

{

String[] name= {"李明","王五","张杰","王强","赵二","李四","张三"};

int[] age= {26,27,33,45,19,23,41};

for(int i=0;i<7;i++)

{

Thread t1=new InformationThread(name[i],age[i]);

threadPool.execute(t1);

}

}

 

}

运行上述程序结果如下：

 

pool-1-thread-3:大家好，我是张杰我今年33岁当前时间为：1520424000186

pool-1-thread-1:大家好，我是李明我今年26岁当前时间为：1520424000186

pool-1-thread-2:大家好，我是王五我今年27岁当前时间为：1520424000186

张杰要准备释放许可证了，当前时间为：1520424001187

李明要准备释放许可证了，当前时间为：1520424001187

王五要准备释放许可证了，当前时间为：1520424001187

当前可使用的许可数为：0

当前可使用的许可数为：0

当前可使用的许可数为：0

pool-1-thread-4:大家好，我是王强我今年45岁当前时间为：1520424001187

pool-1-thread-2:大家好，我是张三我今年41岁当前时间为：1520424001187

pool-1-thread-1:大家好，我是李四我今年23岁当前时间为：1520424001187

李四要准备释放许可证了，当前时间为：1520424002187

王强要准备释放许可证了，当前时间为：1520424002187

当前可使用的许可数为：0

张三要准备释放许可证了，当前时间为：1520424002187

pool-1-thread-5:大家好，我是赵二我今年19岁当前时间为：1520424002187

当前可使用的许可数为：0

当前可使用的许可数为：0

赵二要准备释放许可证了，当前时间为：1520424003188

当前可使用的许可数为：2

以上是非公平信号量，将建立Semaphore对象的语句改为如下语句：

 

private static final Semaphore semaphore=new Semaphore(3,true);

运行程序：

 

pool-1-thread-2:大家好，我是王五我今年27岁当前时间为：1520424286454

pool-1-thread-3:大家好，我是张杰我今年33岁当前时间为：1520424286454

pool-1-thread-1:大家好，我是李明我今年26岁当前时间为：1520424286454

pool-1-thread-1:李明要准备释放许可证了，当前时间为：1520424287455

当前可使用的许可数为：0

pool-1-thread-2:王五要准备释放许可证了，当前时间为：1520424287455

pool-1-thread-3:张杰要准备释放许可证了，当前时间为：1520424287455

当前可使用的许可数为：0

当前可使用的许可数为：1

pool-1-thread-1:大家好，我是李四我今年23岁当前时间为：1520424287455

pool-1-thread-5:大家好，我是赵二我今年19岁当前时间为：1520424287455

pool-1-thread-4:大家好，我是王强我今年45岁当前时间为：1520424287455

pool-1-thread-4:王强要准备释放许可证了，当前时间为：1520424288456

当前可使用的许可数为：0

pool-1-thread-1:李四要准备释放许可证了，当前时间为：1520424288456

pool-1-thread-3:大家好，我是张三我今年41岁当前时间为：1520424288456

pool-1-thread-5:赵二要准备释放许可证了，当前时间为：1520424288456

当前可使用的许可数为：0

当前可使用的许可数为：0

pool-1-thread-3:张三要准备释放许可证了，当前时间为：1520424289456

当前可使用的许可数为：2

3.实现单例模式

 

        将创建信号量对象语句修改如下：

 

private static final Semaphore semaphore=new Semaphore(1);

        运行程序，结果如下：

 

pool-1-thread-1:大家好，我是李明我今年26岁当前时间为：1520424379699

pool-1-thread-1:李明要准备释放许可证了，当前时间为：1520424380700

当前可使用的许可数为：0

pool-1-thread-2:大家好，我是王五我今年27岁当前时间为：1520424380700

pool-1-thread-2:王五要准备释放许可证了，当前时间为：1520424381701

当前可使用的许可数为：0

pool-1-thread-3:大家好，我是张杰我今年33岁当前时间为：1520424381701

pool-1-thread-3:张杰要准备释放许可证了，当前时间为：1520424382702

当前可使用的许可数为：0

pool-1-thread-4:大家好，我是王强我今年45岁当前时间为：1520424382702

pool-1-thread-4:王强要准备释放许可证了，当前时间为：1520424383702

当前可使用的许可数为：0

pool-1-thread-5:大家好，我是赵二我今年19岁当前时间为：1520424383702

pool-1-thread-5:赵二要准备释放许可证了，当前时间为：1520424384702

当前可使用的许可数为：0

pool-1-thread-1:大家好，我是李四我今年23岁当前时间为：1520424384702

pool-1-thread-1:李四要准备释放许可证了，当前时间为：1520424385702

当前可使用的许可数为：0

pool-1-thread-2:大家好，我是张三我今年41岁当前时间为：1520424385702

pool-1-thread-2:张三要准备释放许可证了，当前时间为：1520424386703

当前可使用的许可数为：0

        如上可知，如果将给定许可数设置为1，就如同一个单例模式，即单个停车位，只有一辆车进，然后这辆车出来后，下一辆车才能进。

 

4.总结

 

        Semaphore主要用于控制当前活动线程数目，就如同停车场系统一般，而Semaphore则相当于看守的人，用于控制总共允许停车的停车位的个数，而对于每辆车来说就如同一个线程，线程需要通过acquire()方法获取许可，而release()释放许可。如果许可数达到最大活动数，那么调用acquire()之后，便进入等待队列，等待已获得许可的线程释放许可，从而使得多线程能够合理的运行。

--------------------- 

 

java线程里面Lock、synchronized 都是互斥锁，只允许一个线程进行通信。但是semaphore是允许一组授权许可，每个线程都可以必须拿到一组授权许可才可以进行执行，否则只能等待。其他线程释放许可才可以，这里的一组授权许可可以是1个许可，也可以是多个许可。

例如：

package thread.semaphore;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {
	public static void main(String[] args) {
		ExecutorService pool = Executors.newCachedThreadPool();
		final Semaphore semaphore = new Semaphore(3);//任务当中允许执行的最大许可数
		for (int i = 0; i < 10; i++) {
			final int c = i;
			pool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						semaphore.acquire();//每个线程进来都取一个许可
//						semaphore.acquire(2);//每个线程进来都取2个许可
						System.out.println(c+"已经获得许可证了，当前时间为："+System.currentTimeMillis());
						System.out.println("当前任务："+c+"被"+Thread.currentThread().getName()+"执行啦！当前时间："+System.currentTimeMillis());
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}finally {
						System.out.println(c+"要准备释放许可证了，当前时间为："+System.currentTimeMillis());
						semaphore.release();//每个线程都释放1个许可
//						semaphore.release(2);//每个线程都是释放2个许可。注意的是如果释放的许可数小于每次取得的许可数则程序会死锁
						System.out.println("当前可使用的许可数为："+semaphore.availablePermits());
					}
				}
			});
		}
		pool.shutdown();
	}
}

 

 开始的时候三个线程同时拿到授权。然后某个线程执行完成之后释放授权，另外一个等待的线程立即获得授权，保证每次并发最大也只有三个线程数。

 

注意：

release必须放在finally里面去执行，避免异常导致许可证不能被释放。

如果acquire（200）拿到的许可证太多，那么当前初始化也就只有3个许可证的话，那么该线程就会一直等待下去，不会执行。

如果release（200）释放的许可太大，那么下一次几乎所有的线程都可以拿到许可证，那么失去了许可证的意义了。