信号量在操作系统中一般用来管理数量有限的资源.每类资源有一个对应的信号量.信号量的值表示资源的可用数量.在使用资源时,要先从该信号量上获取一个使用许可.成功获取许可之后,资源可用数量减1.在持有许可期,使用者可以对获取资源进行操作.完成对资源的使用之后,需要在信号量上释放一个许可,资源可用数加1,允许其他使用者获取资源.当资源可用数为0的时候,需要获取资源的线程以阻塞的方式来等待资源变为可用,或者过段时间之后再检查资源是否变为可用.
在java中有相应的Semaphore实现类,在创建Semaphore类的对象时指定资源的可用数,通过acquire方法以阻塞式的方式获取许可,而tryAcquire方法以非阻塞式的方式来获取许可.当需要释放许可时,使用release方法.Semaphore类也支持同时获取和释放多个资源的许可.通过acquire方法获取许可的过程是可以被中断的.如果不希望被中断,那么可以使用acquireUninterruptibly方法.Semaphore也支持在分配许可时使用公平模式,通过把构造方法的第二个参数设置为true来使用该模式.在公平模式下,当资源可用时,等待线程按照调用acquire方法申请资源的顺序依次获取许可.在进行资源管理时,一般使用公平模式,以避免造成线程饥渴问题.需要注意的是获取资源时,通过synchronized关键词或锁声明同步.这是因为Semaphore类只是一个资源数量的抽象表示,并不负责管理资源对象本身,可能有多个线程同时获取到资源使用许可,因此需要使用同步机制避免数据竞争.
使用信号量管理资源的示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
import
java.util.*;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
import
java.util.concurrent.Semaphore;
import
java.util.concurrent.locks.ReentrantLock;
/**
* 信号量使用详解,使用信号量来管理有限的资源
* User: ketqi
* Date: 2013-01-27 12:29
*/
public
class
SemaphoreDemo {
/** 可重入锁,对资源列表进行同步 */
private
final
ReentrantLock lock =
new
ReentrantLock();
/** 信号量 */
private
final
Semaphore semaphore;
/** 可使用的资源列表 */
private
final
LinkedList<Object> resourceList =
new
LinkedList<Object>();
public
SemaphoreDemo(Collection<Object> resourceList) {
this
.resourceList.addAll(resourceList);
this
.semaphore =
new
Semaphore(resourceList.size(),
true
);
}
/**
* 获取资源
*
* @return 可用的资源
* @throws InterruptedException
*/
public
Object acquire()
throws
InterruptedException {
semaphore.acquire();
lock.lock();
try
{
return
resourceList.pollFirst();
}
finally
{
lock.unlock();
}
}
/**
* 释放或者归还资源
*
* @param resource 待释放或归还的资源
*/
public
void
release(Object resource) {
lock.lock();
try
{
resourceList.addLast(resource);
}
finally
{
lock.unlock();
}
semaphore.release();
}
public
static
void
main(String[] args) {
//准备2个可用资源
List<Object> resourceList =
new
ArrayList<>();
resourceList.add(
"Resource1"
);
resourceList.add(
"Resource2"
);
//准备工作任务
final
SemaphoreDemo demo =
new
SemaphoreDemo(resourceList);
Runnable worker =
new
Runnable() {
@Override
public
void
run() {
Object resource =
null
;
try
{
//获取资源
resource = demo.acquire();
System.out.println(Thread.currentThread().getName() +
"\twork on\t"
+ resource);
//用resource做工作
Thread.sleep(
1000
);
System.out.println(Thread.currentThread().getName() +
"\tfinish on\t"
+ resource);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
finally
{
//归还资源
if
(resource !=
null
) {
demo.release(resource);
}
}
}
};
//启动9个任务
ExecutorService service = Executors.newCachedThreadPool();
for
(
int
i =
0
; i <
9
; i++) {
service.submit(worker);
}
service.shutdown();
}
}
转载:http://ketqi.blog.51cto.com/1130608/1127274
|