信号量Semaphore是一个计数信号量,用来保护一个或多个共享资源的访问,是Java Concurrent包下提供的另一种同步方式:使用加锁方式同步,一个时间只能有一个线程访问共享资源,而使用Senmaphore可以控制多个线程同时访问共享资源。
Semaphore信号量
Semaphore可以控制某个资源可被同时访问的个数(通过构造方法设置):
- 通过 acquire() 获取一个许可,如果没有就等待。
- release() 释放一个许可。
比如在Windows下可以设置共享文件的最大客户端访问个数。 Semaphore实现的功能就类似厕所有5个坑,假如有10个人要上厕所,那么同时只能有多少个人去上厕所呢?同时只能有5个人能够占用,当5个人中 的任何一个人让开后,其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会,也可以是按照先来后到的顺序获得机会(和lock类似可以设置为公平模式),这取决于构造Semaphore对象时传入的参数选项。
单个信号量(二进制信号量,计数只有0和1)的Semaphore对象可以实现互斥锁的功能,并且可以是由一个线程获得了“锁”,再由另一个线程释放“锁”,这可应用于死锁恢复的一些场合。
Semaphore维护了当前访问的个数,提供同步机制,控制同时访问的个数。在数据结构中链表可以保存“无限”的节点,用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能,但实现上要复杂些。
下面代码参考Java并发编程实践,利用Semaphore控制使能够有两个线程同一时段访问共享数据。
package MyThread;
import java.util.Date;
import java.util.concurrent.Semaphore;
//打印任务队列,共享数据
class PrintQueue{
private Semaphore semaphore;
PrintQueue(int num){
semaphore=new Semaphore(num);
}
public void printJob(){
try {
//获取
semaphore.acquire();
System.out.printf("%s printJob time %s \n",Thread.currentThread().getName(),new Date());
Thread.sleep(3000);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
//释放
semaphore.release();
}
}
}
//模拟打印机
class PrintMachine implements Runnable{
private PrintQueue printQueue;
PrintMachine(PrintQueue printQueue){
this.printQueue=printQueue;
}
@Override
public void run() {
// TODO Auto-generated method stub
printQueue.printJob();
}
}
public class MySemaphoreTest {
public static void main(String[] arg){
PrintQueue printQueue=new PrintQueue(2);
//创建5个线程访问共享数据
for(int i=0;i<5;i++){
new Thread(new PrintMachine(printQueue)).start();
}
}
}
- 结果,可以看出同一时段可以有两个线程同时访问共享数据。
Thread-1 printJob time Mon Jun 06 15:55:42 CST 2016
Thread-0 printJob time Mon Jun 06 15:55:42 CST 2016
Thread-2 printJob time Mon Jun 06 15:55:45 CST 2016
Thread-3 printJob time Mon Jun 06 15:55:45 CST 2016 - Thread-4 printJob time Mon Jun 06 15:55:48 CST 2016
Semaphore类位于java.util.concurrent包下,它提供了2个构造器:
1
2
3
4
5
6
|
public
Semaphore(
int
permits) {
//参数permits表示许可数目,即同时可以允许多少线程进行访问
sync =
new
NonfairSync(permits);
}
public
Semaphore(
int
permits,
boolean
fair) {
//这个多了一个参数fair表示是否是公平的,即等待时间越久的越先获取许可
sync = (fair)?
new
FairSync(permits) :
new
NonfairSync(permits);
}
|
下面说一下Semaphore类中比较重要的几个方法,首先是acquire()、release()方法:
1
2
3
4
|
public
void
acquire()
throws
InterruptedException { }
//获取一个许可
public
void
acquire(
int
permits)
throws
InterruptedException { }
//获取permits个许可
public
void
release() { }
//释放一个许可
public
void
release(
int
permits) { }
//释放permits个许可
|
acquire()用来获取一个许可,若无许可能够获得,则会一直等待,直到获得许可。
release()用来释放许可。注意,在释放许可之前,必须先获获得许可。
这4个方法都会被阻塞,如果想立即得到执行结果,可以使用下面几个方法:
1
2
3
4
|
public
boolean
tryAcquire() { };
//尝试获取一个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public
boolean
tryAcquire(
long
timeout, TimeUnit unit)
throws
InterruptedException { };
//尝试获取一个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
public
boolean
tryAcquire(
int
permits) { };
//尝试获取permits个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public
boolean
tryAcquire(
int
permits,
long
timeout, TimeUnit unit)
throws
InterruptedException { };
//尝试获取permits个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
|
另外还可以通过availablePermits()方法得到可用的许可数目。
下面通过一个例子来看一下Semaphore的具体使用:
假若一个工厂有5台机器,但是有8个工人,一台机器同时只能被一个工人使用,只有使用完了,其他工人才能继续使用。那么我们就可以通过Semaphore来实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
|
public
class
Test {
public
static
void
main(String[] args) {
int
N =
8
;
//工人数
Semaphore semaphore =
new
Semaphore(
5
);
//机器数目
for
(
int
i=
0
;i<N;i++)
new
Worker(i,semaphore).start();
}
static
class
Worker
extends
Thread{
private
int
num;
private
Semaphore semaphore;
public
Worker(
int
num,Semaphore semaphore){
this
.num = num;
this
.semaphore = semaphore;
}
@Override
public
void
run() {
try
{
semaphore.acquire();
System.out.println(
"工人"
+
this
.num+
"占用一个机器在生产..."
);
Thread.sleep(
2000
);
System.out.println(
"工人"
+
this
.num+
"释放出机器"
);
semaphore.release();
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
|
执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
1
|
工人
0
占用一个机器在生产...
工人
1
占用一个机器在生产...
工人
2
占用一个机器在生产...
工人
4
占用一个机器在生产...
工人
5
占用一个机器在生产...
工人
0
释放出机器
工人
2
释放出机器
工人
3
占用一个机器在生产...
工人
7
占用一个机器在生产...
工人
4
释放出机器
工人
5
释放出机器
工人
1
释放出机器
工人
6
占用一个机器在生产...
工人
3
释放出机器
工人
7
释放出机器
工人
6
释放出机器
|
下面对上面说的三个辅助类进行一个总结:
1)CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:
CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后,它才执行;
而CyclicBarrier一般用于一组线程互相等待至某个状态,然后这一组线程再同时执行;
另外,CountDownLatch是不能够重用的,而CyclicBarrier是可以重用的。
2)Semaphore其实和锁有点类似,它一般用于控制对某组资源的访问权限。