JAVA并发框架之Semaphore实现生产者与消费者模型
锁和信号量（
Semaphore
）是实现多线程同步的两种常用的手段。信号量需要初始化一个许可值，许可值可以大于0，也可以小于0，也可以等于0.
如果大于0，表示，还有许可证可以发放，线程不会被阻塞；
如果小于或者等于0，表示，没有许可证可以发放了，线程被阻塞住了。
它有两个常用的操作，
acquire()申请许可证，如果有，就可以获得，如果没有就等待了。
release()，归还许可证，保证循环使用。
看一个例子，就会明白了，还是实现上次的那个生产者和消费者的例子。
我们假设有一个篮子，最多可以放3个苹果，有多个人可以放苹果，也有多个人可以拿走苹果。
public
class
Apple {
private
String
name
;
public
Apple(String
name
){
this
.
name
=
name
;
}
@Override
public
String toString() {
//
TODO
Auto-generated method stub
return
name
;
}
}
public
class
Basket {
private
List
bascket
=
new
ArrayList(10);
Semaphore
mutex
=
new
Semaphore(1);
Semaphore
isFull
=
new
Semaphore(10);
Semaphore
isEmpty
=
new
Semaphore(0);
public
void
put(Apple
app
)
throws
InterruptedException{
//大于0，就放行
//acquire，就是减操作，如果小于0，就阻塞
//release，就是加操作，如果大于0，就不会被阻塞
isFull
. acquire();
try
{
mutex
. acquire();
bascket
.add(
app
);
}
finally
{
mutex
.release();
isEmpty
.release();
}
}
public
Apple take()
throws
InterruptedException{
Apple
app
;
isEmpty
. acquire();
try
{
mutex
. acquire();
app
=
bascket
.remove(0);
}
finally
{
mutex
.release();
isFull
.release();
}
return
app
;
}
}
//消费者
public
class
Consumer
implements
Runnable{
private
Basket
bascket
;
private
String
name
;
public
Consumer(Basket
bascket
,String
name
){
this
.
bascket
=
bascket
;
this
.
name
=
name
;
}
public
void
run(){
while
(
true
){
try
{
System.
out
.println(
name
+
":consumer"
+
bascket
.take());
}
catch
(InterruptedException
e1
) {
//
TODO
Auto-generated catch block
e1
.printStackTrace();
}
try
{
Thread. sleep(1000);
}
catch
(InterruptedException
e
) {
//
TODO
Auto-generated catch block
e
.printStackTrace();
}
}
}
}
//生产者
public
class
Producer
implements
Runnable{
private
Basket
bascket
;
private
String
name
;
public
Producer(Basket
bascket
,String
name
){
this
.
bascket
=
bascket
;
this
.
name
=
name
;
}
public
void
run(){
while
(
true
){
try
{
System.
out
.println(
name
+
"produce.."
);
bascket
. put(
new
Apple(
"name"
+
new
Random()));
}
catch
(InterruptedException
e
) {
//
TODO
Auto-generated catch block
e
.printStackTrace();
}
try
{
Thread. sleep(1000);
}
catch
(InterruptedException
e
) {
//
TODO
Auto-generated catch block
e
.printStackTrace();
}
}
}
}
public
class
TestDemo {
public
static
void
main(String
args
[]){
Basket
bascket
=
new
Basket();
Consumer
c1
=
new
Consumer(
bascket
,
"c1"
);
Producer
p1
=
new
Producer(
bascket
,
"p1"
);
Producer
p2
=
new
Producer(
bascket
,
"p2"
);
//线程池管理
ExecutorService
service
= Executors. newCachedThreadPool();
service
.execute(
c1
);
service
.execute(
p1
);
service
.execute(
p2
);
}
}
一定要注意，上面acquire的顺序，如果不正确，所有的线程就会被阻塞了。
信号量的实现原理会在源代码中进行分析。
来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/30024515/viewspace-1429123/，如需转载，请注明出处，否则将追究法律责任。
转载于:http://blog.itpub.net/30024515/viewspace-1429123/