- Semaphore的介绍
单词Semaphore的中文含义就是信号、信号系统的意思，此类的主要作用就是限制线程并发的数量。
举个例子，一个屋子里有10个人，但只有一个窄门可以出去，这个窄门一次最多只能通过一人，这样就限制了同时出门的人数，同理也就是限制了线程并发的数量，这也就是Semaphore类要达到的目的。
- 类Semaphore的同步性
多线程中的同步就是多个线程排队去执行任务，一个一个执行，不会有线程安全的问题。
构造函数参数permits是许可的意思，代表同一时间内，最多允许多少个线程同时执行acquire()和release()之间的代码。
无参方法acquire()的作用是默认使用1个许可。
package com.wjg.unit1;
import java.util.concurrent.Semaphore;
public class Service {
private Semaphore semaphore = new Semaphore(1);
public void testMethod(){
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
}
}
//运行类
package com.wjg.unit1;
public class Run {
public static void main(String[] args) {
Service service = new Service();
Run run = new Run();
ThreadA a = run.new ThreadA(service);
a.setName("a");
a.start();
ThreadB b = run.new ThreadB(service);
b.setName("b");
b.start();
ThreadC c = run.new ThreadC(service);
c.setName("c");
c.start();
}
public class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
public class ThreadB extends Thread {
private Service service;
public ThreadB(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
public class ThreadC extends Thread {
private Service service;
public ThreadC(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
}
运行结果：
a begin timer=1487748505823
a end timer=1487748510826
b begin timer=1487748510827
b end timer=1487748515828
c begin timer=1487748515828
c end timer=1487748520833
- 构造函数permits参数作用
参数permits代表同一时间内，最多允许有x个线程可以执行acquire()和release()之间的代码。我们将上例的Service改造一下，Run类不变
package com.wjg.unit1;
import java.util.concurrent.Semaphore;
public class Service {
//我们将premits参数值改为2
private Semaphore semaphore = new Semaphore(2);
public void testMethod(){
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
}
}
运行结果：
a begin timer=1487749198356
b begin timer=1487749198357
b end timer=1487749203359
a end timer=1487749203359
c begin timer=1487749203359
c end timer=1487749208360
- 方法acquire(int permits)使用
方法acquire(int permits)功能就是每调用1次就使用x个许可。
这个有一点说明一下，acquire方法做的是减法操作，release方法做的是加法操作，构造函数new Semaphore(5)中的5并不是最终的许可数量，仅仅是初始化的状态值，是可以动态改变的。
- 方法acquireUninterruptibly()使用
此方法作用是使等待进入acquire()方法的线程，不允许被中断。我们先看一下被中断的例子
package com.wjg.unit1;
import java.util.concurrent.Semaphore;
public class Service {
private Semaphore semaphore = new Semaphore(1);
public void testMethod(){
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
for (int i = 0; i < Integer.MAX_VALUE; i++) {
String newString = new String();
Math.random();
}
System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
} catch (InterruptedException e) {
System.out.println("线程"+Thread.currentThread().getName()+"进入了catch");
e.printStackTrace();
}finally {
semaphore.release();
}
}
}
package com.wjg.unit1;
public class Run {
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
Run run = new Run();
ThreadA a = run.new ThreadA(service);
a.setName("a");
a.start();
ThreadB b = run.new ThreadB(service);
b.setName("b");
b.start();
Thread.sleep(1000);
//中断b线程
b.interrupt();
System.out.println("main 中断了b");
}
public class ThreadA extends Thread{
private Service service;
public ThreadA(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
public class ThreadB extends Thread{
private Service service;
public ThreadB(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
}
执行结果：
a begin timer=1487751504264
main 中断了b
java.lang.InterruptedException
线程b进入了catch
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:996)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1303)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:317)
at com.wjg.unit1_1_4.Service.testMethod(Service.java:10)
at com.wjg.unit1_1_4.Run$ThreadB.run(Run.java:46)
a end timer=1487751505711
以上的例子就是把等待获取许可的线程B手动结束了，下面的例子是利用acquireUninterruptibly()方法阻止等待获取许可的线程中断。
package com.wjg.unit1_1_4;
import java.util.concurrent.Semaphore;
public class Service {
private Semaphore semaphore = new Semaphore(1);
public void testMethod(){
try {
//此处阻止等待获取许可的线程被中断
semaphore.acquireUninterruptibly();
System.out.println(Thread.currentThread().getName()+" begin timer="+System.currentTimeMillis());
for (int i = 0; i < Integer.MAX_VALUE/50; i++) {
String newString = new String();
Math.random();
}
System.out.println(Thread.currentThread().getName()+" end timer="+System.currentTimeMillis());
} finally {
semaphore.release();
}
}
}
执行结果
a begin timer=1487751777062
main 中断了b
a end timer=1487751778455
b begin timer=1487751778455
b end timer=148775177963
- 方法availablePermits()和drainPermits()使用
availablePermits() 返回Semaphore对象中当前可用的许可数
drainPermits() 获取并返回立即可用的许可个数，并且将可用许可置0
- 方法getQueueLength()和hasQueuedThreads()使用
getQueueLength() 返回等待可续的线程个数
hasQueuedThreads() 判断是否还有等待许可的线程
这两个方法通常都是在判断当前有没有等待许可的线程信息时使用。
- 公平与非公平信号量
公平信号量是指获得锁的顺序与线程启动的顺序有关，非公平信息量就是无关的了。
非公平信号量线程启动的顺序与调用semaphore.acquire()的顺序无关，也就是线程先启动了并不代表先获得许可。
公平与不公平通过Semaphore类的构造函数new Semaphore(int permits,boolean fair)的第二个参数fair决定。
- 方法tryAcquire()作用
无参的tryAcquire()作用就是尝试地获得一个许可，如果获取不到则返回false，此方法通常与if语句结合使用，具有不阻塞的特点。
-
方法tryAcquire(int permits)使用
作用是尝试获取x个许可，如果湖区不到则返回false。
- 方法tryAcquire(long timeout,TimeUnit unit)使用
作用是在指定的时间内尝试地获取1个许可，如果获取不到则返回false，此处会有阻塞。
- 方法tryAcquire(int permits,long timeout,TimeUnit unit)使用
作用是在指定的时间内尝试地获取x个许可，如果获取不到则返回false，此处会有阻塞。
注：本系列笔记均参考自《Java并发编程 核心方法与框架》此书。