Semaphore
信号量，用于控制并发的线程的数目。信号量在JUC下的实现，每当一个线程进入临界区信号量减少，线程释放锁后信号量增加。
1.1 简单使用
初始化permit为10的信号量，acquire减少2，release增加2，本质上等价于permit=5,acquire release都是1的信号量，并发线程数目为5个。
public class Service { private Semaphore semaphore = new Semaphore(10); public void testMethod(){ try { semaphore.acquire(2); System.out.println(Thread.currentThread().getName()+" begain time"+System.currentTimeMillis()); Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+" end time"+System.currentTimeMillis()); semaphore.release(2); } }
Thread类把service对象注入。
public class Thread extends java.lang.Thread { private Service service; public Thread(Service service) { this.service = service; } @Override public void run() { service.testMethod(); } }
测试类同时开启10个线程。
public class Run { public static void main(String[] args) { Service service = new Service(); for (int i = 0; i < 10; i++) { Thread thread = new Thread(service); thread.setName(i+""); thread.start(); } } }
从控制台的输出结果看到同时最多有5个线程同时在处理机上。
0 begain time1556026437118 1 begain time1556026437118 3 begain time1556026437119 2 begain time1556026437119 4 begain time1556026437119 0 end time1556026442120 2 end time1556026442120 5 begain time1556026442120 3 end time1556026442120 1 end time1556026442120 7 begain time1556026442121 6 begain time1556026442121 4 end time1556026442120 8 begain time1556026442121 9 begain time1556026442121 5 end time1556026447124 9 end time1556026447124 7 end time1556026447124 6 end time1556026447124 8 end time1556026447124
1.2 release与permit
release每次增加permit的数目，可以大于初始化Semaphore时permit的数量。
public class testReleasePermit { public static void main(String[] args) throws InterruptedException { Semaphore semaphore = new Semaphore(4); System.out.println(semaphore.availablePermits()); semaphore.acquire(4); System.out.println(semaphore.availablePermits()); semaphore.release(1); semaphore.release(1); semaphore.release(1); semaphore.release(1); System.out.println(semaphore.availablePermits()); semaphore.release(4); System.out.println(semaphore.availablePermits()); } }
初始化4，acquire4次变为0，release4次变为4，继续release变为8。初始化permit只是该信号量在初始化的时候允许的permit数目，而非最大的数目。
4 0 4 8
1.3 信号量和中断
当线程无法获得信号量的时候，该线程会被被park起来，即线程进入了WAITING状态，在WAITING状态的线程在被中断的时候会抛出异常，所以一个线程在acquire失败变成WAITING状态的时候是可以被中断的
public class RunInter { public static void main(String[] args) throws InterruptedException { serviceInter serviceInter = new serviceInter(); myThread thread1 = new myThread(serviceInter); myThread thread2 = new myThread(serviceInter); thread1.start(); thread2.start(); Thread.sleep(10); System.out.println(thread2.getState()); thread2.interrupt(); } }
public class serviceInter { private Semaphore semaphore = new Semaphore(1); public void testMethod() { try { semaphore.acquire(); System.out.println(Thread.currentThread().getName()+" begain"+System.currentTimeMillis()); Thread.sleep(1000); System.out.println(Thread.currentThread().getName()+" end"+System.currentTimeMillis()); semaphore.release(); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+" 进入了中断"); e.printStackTrace(); } } }
Thread-0先获得了信号量并执行，Thread-1没有获得信号量进入WAITING状态，并且在main线程里调用thread2的interrupt方法后抛出了异常。
Thread-0 begain1556029651021 WAITING Thread-1 进入了中断 java.lang.InterruptedException at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304) at java.util.concurrent.Semaphore.acquire(Semaphore.java:312) at Semaphore.serviceInter.testMethod(serviceInter.java:12) at Semaphore.myThread.run(myThread.java:14) Thread-0 end1556029655608
把acquire改成acquireUninterruptibly，禁止中断没有获得信号量的线程，同样的测试代码结果如下。虽然还是抛出了异常但是异常是在thread2获得了信号量之后抛出的。
Thread-0 begain1556030019636 WAITING Thread-0 end1556030020637 Thread-1 begain1556030020638 Thread-1 进入了中断 java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at Semaphore.serviceNonInter.testMethod(serviceNonInter.java:12) at Semaphore.myThreadNoInter.run(myThreadNoInter.java:14)
1.4获取可用的信号量的个数
-
availablePermits,返回可用的信号量的个数 -
drainPermits，返回可用的信号量的个数并清零
public class getAvailable { public static void main(String[] args) throws InterruptedException { Semaphore semaphore = new Semaphore(10); semaphore.acquire(4); System.out.println(semaphore.availablePermits()); System.out.println(semaphore.drainPermits()); System.out.println(semaphore.availablePermits()); } }
1.5 获取在等待信号量线程的个数
- getQueueLength，获取在排队获取线程的个数
- hasQueueThreads，判断是否有线程在等待
getQueueLength并不是准确的，比如同时开启30个线程，在第一个线程获取信号量的时候剩下29个线程还没有完成启动过程，所以理应有29个线程在等待但最终输出的数字个能小于等于29。
比如我同时开启5个线程，在testMethod中打印getQueueLength，在第一个线程启动的时候并没有打印4而是2。
public static void main(String[] args) throws InterruptedException { serviceInter serviceInter = new serviceInter(); for (int i = 0; i < 5; i++) { myThread thread = new myThread(serviceInter); thread.start(); } }
Thread-0 begain1556030481874 2 Thread-0 end1556030482877 Thread-1 begain1556030482878 3 Thread-1 end1556030483883 Thread-2 begain1556030483883 2 Thread-2 end1556030484887 Thread-3 begain1556030484888 1 Thread-3 end1556030485888 Thread-4 begain1556030485888 0 Thread-4 end1556030486891
1.5 公平和非公平信号量
在信号量中，公平指的是获取信号量的顺序和启动线程的顺序相同，即先启动的线程能够先获取信号量，非公平则不提供这种保证，默认情况下是非公平的，因为这样效率更高。
理论上非公平信号量获取信号量的顺序和启动的顺序无关，但是我测试的结果却是按照顺序来的。
1.6 tryAcquire
一种非阻塞的实现，获取线程失败的时候不进入WAITING状态而是返回false，配合if判断可实现一个简单的CAS乐观锁。
把Service中的acquire改成truAcquire,可以看到开启的线程同时返回，无论是获得信号量的还是没有获得信号量的线程。
public class Service {
private Semaphore semaphore = new Semaphore(1);
private void testMethod(){
try {
if (semaphore.tryAcquire(1)){
System.out.println(Thread.currentThread().getName()+" 进入");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
semaphore.release();
}else {
System.out.println(Thread.currentThread().getName()+" 未成功进入");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
0 进入
1 未成功进入
2 未成功进入
3 未成功进入
4 未成功进入
tryAcquire还有两个重载的方法，用于指定一次获取多少个信号量，和没有获得信号量等待的时间。
1.7 多处理与单处理
public class Service { private Semaphore semaphore = new Semaphore(3); private ReentrantLock lock = new ReentrantLock(); public void sayHello(){ try { semaphore.acquire(); lock.lock(); System.out.println(Thread.currentThread().getName()+" 获得了信号量"); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } lock.unlock(); semaphore.release(); } }
作者这个例子想演示的效果是同时有多个线程获得信号量，但获得信号量的线程必须获得锁才能工作。用信号量来控制工作线程的数目，这就是所谓的多进路。用可重入锁来实现只能有一个线程获得锁，这就是单处理和多处理的区别。
这和只使用一个锁有什么区别的呢？从打印的结果来看并没有任何区别，加不加信号量情况下的单处理结果是一样的。从对线程状态的改变来看也没看出有什么区别，线程无法获得信号量的时候被挂在信号量的AQS的队列里，线程获得了信号量没有获得锁的时候被挂在了锁的AQS的队列里，区别在哪里呢？？？？
1.8 字符串池
该池实现这样一个功能：池中的字符串是有限的，同时最多有permit个线程可以从字符串池中获取字符串。
看了这个介绍后我自己写了一版本，这个版本是错的。Run和myThread都和前面没什么区别，stringPool实现了字符串池，我的理解很简单设置一个permit为3的信号量，在get方法里的remove方法前面用acquire拦住，这样同时最多只能有三个线程执行remove方法。听起来是对的，但是报错了。
public class stringPool { private int poolSize = 5; private int semaphorePermit = 3; private Semaphore semaphore = new Semaphore(semaphorePermit); private List<String> pool; public stringPool() { pool = new ArrayList<>(poolSize); for (int i=0;i<poolSize;i++){ pool.add(i+""); } } public String get(){ String string = null; try { semaphore.acquire(); } catch (InterruptedException e) { e.printStackTrace(); } string = pool.remove(0); //System.out.println(pool); return string; } public void put(String string){ pool.add(string); //System.out.println(pool); semaphore.release(); } }
public class myThread extends Thread { private stringPool stringPool; public myThread(Semaphore.Pool.stringPool stringPool) { this.stringPool = stringPool; } @Override public void run() { String s = stringPool.get(); System.out.println(Thread.currentThread().getName()+" 获得了"+s); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } stringPool.put(s); System.out.println(Thread.currentThread().getName()+" 归还了"+s); } }
public class Run { public static void main(String[] args) { stringPool stringPool = new stringPool(); for (int i = 0; i < 10; i++) { myThread thread = new myThread(stringPool); thread.setName(i+""); thread.start(); } } }
控制台抛出的异常，显然是List为空还执行remove方法。我的池子里最多有5个字符串，信号量设置的为3，为什么还会越界呢？？？？？？permit为3，也就是同时最多有3个线程可以从pool里取字符，poolSize为5，所以pool里字符的个数应该是大于等于2的。
0 获得了0 1 获得了1 2 获得了2 1 归还了1 3 获得了3 0 归还了0 2 归还了2 5 获得了1 4 获得了4 3 归还了3 7 获得了3 6 获得了2 4 归还了4 5 归还了1 Exception in thread "8" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:657) at java.util.ArrayList.remove(ArrayList.java:496) at Semaphore.Pool.stringPool.get(stringPool.java:28) at Semaphore.Pool.myThread.run(myThread.java:12) 7 归还了3 9 获得了3 6 归还了2 9 归还了3
