Condition是做什么用的了?Condition是用来实现线程间通信的,说到这,可能很多人都想到了wait和notify以及notifyAll,没错,Condition的功能和他们类似,只是功能更强而已,下面我们就来学习一下线程间通过Condition来实现通信。
Condition也是jdk1.5并发包下的一个接口,原型如下:
public interface Condition {
// 相当于Object的wait方法
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
// 在给定的时间,阻塞
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
// 相当于Object的notify方法
void signal();
// 相当于Object的notifyAll方法
void signalAll();
}
Condition使用说明:
· Condition是个接口,基本的方法就是await()和signal()方法;
· Condition依赖于Lock接口,生成一个Condition的基本代码是lock.newCondition()
· 调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用
Conditon中的await()对应Object的wait();
Condition中的signal()对应Object的notify();
Condition中的signalAll()对应Object的notifyAll()。
下面用官网上的一个示例来说明Condition的使用,代码如下:
public class ConditionDemo {
// 可重入锁
final Lock lock = new ReentrantLock();
// 写线程条件
final Condition notFull = lock.newCondition();
// 读线程条件
final Condition notEmpty = lock.newCondition();
// 缓存队列的深度
final Object[] items = new Object[100];
// 写索引
int putptr = 0;
// 读索引
int takeptr = 0;
// 缓存队列中存在的数据个数
int count = 0;
/**
* 描述:模拟往队列里面放对象
*/
public void put(Object x) throws InterruptedException {
System.out.println("获取写锁!");
// 上锁
lock.lock();
try {
/*
* 如果当前队列里面的对象个数和队列的深度相同,说明队列已经满了,准备阻塞写线程
* 注意,此处用while而不用if,是为了防止假唤醒
*/
while (count == items.length){
System.out.println("队列已满,阻塞写线程!");
// 阻塞写线程
notFull.await();
}
// 写数据
System.out.println("写入的数据为:"+x);
items[putptr] = x;
// 如果当前的写索引和队列的深度相同,说明队列已经写满了,所以需要从索引0开始写数据
if (++putptr == items.length){
putptr = 0;
}
// 队列中的数据个数递增
++count;
// 唤醒读线程
notEmpty.signal();
}finally {
System.out.println("释放写锁!");
// 释放锁
lock.unlock();
}
}
/**
* 描述:模拟从队列里面取对象
*/
public Object take() throws InterruptedException {
System.out.println("获取读锁!");
// 上锁
lock.lock();
try {
// 如果当前队列里面没有数据,阻塞读线程,此处用while原因同上
while (count == 0){
System.out.println("队列为空,阻塞读线程!");
// 阻塞读线程
notEmpty.await();
}
// 读数据
Object x = items[takeptr];
// 如果读索引和队列的深度相同,说明已经读到了队列的最后一个数据,需要从0开始读
if (++takeptr == items.length){
takeptr = 0;
}
// 队列里面的个数递减
--count;
// 唤醒写线程
notFull.signal();
// 返回读取的对象
return x;
}finally {
System.out.println("释放读锁!");
// 释放锁
lock.unlock();
}
}
public static void main(String[] args) {
final ConditionDemo demo = new ConditionDemo();
// 新建N个写线程,且写比对快
ExecutorService put = Executors.newCachedThreadPool();
put.execute(new Runnable() {
@Override
public void run() {
for(int i=0; i<399; i++){
try {
demo.put("chhliu"+i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
// 新建N个读线程,读比写慢
ExecutorService take = Executors.newCachedThreadPool();
take.execute(new Runnable() {
@Override
public void run() {
while(true){
try {
// 模拟长时间读
Thread.sleep(200);
String message = (String) demo.take();
System.out.println("读取的数据为:"+message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
}
}
首先,我们先让写快,读慢,当写的线程将缓存队列写满之后,写线程就会被阻塞,只有当读线程从队列中读取数据之后,写线程才会被唤醒,测试结果如下:
写入的数据为:chhliu98
释放写锁!
获取写锁!
写入的数据为:chhliu99
释放写锁!
获取写锁!
队列已满,阻塞写线程!
获取读锁!
读取的数据为:chhliu0
释放读锁!
写入的数据为:chhliu100
释放写锁!
获取写锁!
队列已满,阻塞写线程!
.......
读取的数据为:chhliu298
释放读锁!
获取读锁!
队列为空,阻塞读线程!
程序首先会一直写数据,直到队列写满,然后会阻塞写线程,唤醒读线程,读线程读取数据之后,队列未满,然后会唤醒写线程,这样依次交替进行,等所有的数据都读取完之后,会阻塞读线程。
从上面的例子中,我们可以看到,我们同时使用了多个Condition,这在传统的线程通信中是不可能看到的现象,假设缓存队列中已经存满,那么阻塞的肯定是写线程,唤醒的肯定是读线程,相反,阻塞的肯定是读线程,唤醒的肯定是写线程,那么假设只有一个 Condition会有什么效果呢,缓存队列中已经存满,这个Lock不知道唤醒的是读线程还是写线程了,如果唤醒的是读线程,皆大欢喜,如果唤醒的是写 线程,那么线程刚被唤醒,又被阻塞了,这时又去唤醒,这样就浪费了很多时间。
---------------------
作者:牛奋lch
来源:CSDN
原文:https://blog.csdn.net/liuchuanhong1/article/details/53539597
版权声明:本文为博主原创文章,转载请附上博文链接!