Semaphore(信号量)：是一种计数器，用来保护一个或者多个共享资源的访问。如果线程要访问一个资源就必须先获得信号量。如果信号量内部计数器大于0，信号量减1，然后允许共享这个资源；否则，如果信号量的计数器等于0，信号量将会把线程置入休眠直至计数器大于0.当信号量使用完时，必须释放。
实例代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
final
Semaphore semaphore =
new
Semaphore(
2
);
ExecutorService executorService = Executors.newCachedThreadPool();
for
(
int
i =
0
; i <
10
; i++) {
final
int
index = i;
executorService.execute(
new
Runnable() {
public
void
run() {
try
{
semaphore.acquire()；
System.out.println(
"线程:"
+ Thread.currentThread().getName() +
"获得许可:"
+ index);
TimeUnit.SECONDS.sleep(
1
);
semaphore.release();
System.out.println(
"允许TASK个数："
+ semaphore.availablePermits());
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
});
}
executorService.shutdown();
|
构造方法1：
|
1
2
3
|
public
Semaphore(
int
permits) {
sync =
new
NonfairSync(permits);
}
|
permits 初始许可数，也就是最大访问线程数构造方法2：
|
1
2
3
|
public
Semaphore(
int
permits,
boolean
fair) {
sync = (fair)?
new
FairSync(permits) :
new
NonfairSync(permits);
}
|
permits 初始许可数，也就是最大访问线程数
fair 当设置为false时，创建的信号量为非公平模式；当设置为true时，信号量是公平模式
主要方法：
- void acquire() ：从信号量获取一个许可，如果无可用许可前将一直阻塞等待，
- void acquire(int permits) ：获取指定数目的许可，如果无可用许可前也将会一直阻塞等待
- boolean tryAcquire()：从信号量尝试获取一个许可，如果无可用许可，直接返回false，不会阻塞
- boolean tryAcquire(int permits)： 尝试获取指定数目的许可，如果无可用许可直接返回false
- boolean tryAcquire(int permits, long timeout, TimeUnit unit)： 在指定的时间内尝试从信号量中获取许可，如果在指定的时间内获取成功，返回true，否则返回false
- void release()： 释放一个许可，别忘了在finally中使用，注意：多次调用该方法，会使信号量的许可数增加，达到动态扩展的效果，如：初始permits为1， 调用了两次release，最大许可会改变为2
- int availablePermits()： 获取当前信号量可用的许可
JDK 非公平Semaphore实现：
1.使用一个参数的构造创建Semaphore对象时，会创建一个NonfairSync对象实例，并将state值设为传入的值（permits ），
|
1
2
3
|
public
Semaphore(
int
permits) {
sync =
new
NonfairSync(permits);
}
|
NonfairSync间接的继承了AbstractQueuedSynchronizer实现
|
1
2
3
4
5
6
7
8
9
10
11
|
final
static
class
NonfairSync
extends
Sync {
private
static
final
long
serialVersionUID = -2694183684443567898L;
NonfairSync(
int
permits) {
super
(permits);
}
protected
int
tryAcquireShared(
int
acquires) {
return
nonfairTryAcquireShared(acquires);
}
}
|
|
1
2
3
4
5
6
|
abstract
static
class
Sync
extends
AbstractQueuedSynchronizer {
private
static
final
long
serialVersionUID = 1192457210091910933L;
Sync(
int
permits) {
setState(permits);
}
|
AbstractQueuedSynchronizer 的setState方法
|
1
2
3
|
protected
final
void
setState(
int
newState) {
state = newState;
}
|
2.调用tryAcquire方法时，实际是调用NonfairSync的nonfairTryAcquireShared方法，nonfairTryAcquireShared在父类Sync中实现，
Semaphore# tryAcquire方法：
|
1
2
3
|
public
boolean
tryAcquire() {
return
sync.nonfairTryAcquireShared(
1
) >=
0
;
}
|
Sync的nonfairTryAcquireShared方法
|
1
2
3
4
5
6
7
8
9
|
final
int
nonfairTryAcquireShared(
int
acquires) {
for
(;;) {
int
available = getState();
int
remaining = available - acquires;
if
(remaining <
0
||
compareAndSetState(available, remaining))
return
remaining;
}
}
|
nonfairTryAcquireShared 方法通过获取当前的state，以此state减去需要获取信号量的个数，作为剩余个数，如果结果小于0，返回此剩余的个数；如果结果大于等于0，则基于 CAS将state的值设置为剩余个数，当前步骤用到了for循环，所以只有在结果小于0或设置state值成功的情况下才会退出。如果返回的剩余许可个数大于0，tryAcquire方法则返回true；其余返回false。
AbstractQueuedSynchronizer的compareAndSetState方法，
|
1
2
3
4
|
protected
final
boolean
compareAndSetState(
int
expect,
int
update) {
// See below for intrinsics setup to support this
return
unsafe.compareAndSwapInt(
this
, stateOffset, expect, update);
}
|
3.release方法，释放一个许可
|
1
2
3
|
public
void
release() {
sync.releaseShared(
1
);
}
|
AbstractQueuedSynchronizer的releaseShared方法，
|
1
2
3
4
5
6
7
|
public
final
boolean
releaseShared(
int
arg) {
if
(tryReleaseShared(arg)) {
doReleaseShared();
return
true
;
}
return
false
;
}
|
release方法间接的调用了Sync的tryReleaseShared方法，该方法基于Cas 将state的值设置为state+1，一直循环确保CAS操作成功，成功后返回true。
|
1
2
3
4
5
6
7
|
protected
final
boolean
tryReleaseShared(
int
releases) {
for
(;;) {
int
p = getState();
if
(compareAndSetState(p, p + releases))
return
true
;
}
}
|
根据上面分析，可以看得出，Semaphore采用了CAS来实现，尽量避免锁的使用，提高了性能