【java并发】条件阻塞Condition的应用

最新推荐文章于 2022-08-23 14:07:35 发布
最新推荐文章于 2022-08-23 14:07:35 发布
阅读量7.2k 收藏 5
点赞数 10
分类专栏： ● 编程语言 ------【Java并发】 Java并发技术 文章标签： java 并发 线程 Condition 条件阻塞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eson_15/article/details/51559860
版权

Condition将Object监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了synchronized方法和语句的使用，Condition替代了Object监视器方法的使用。

1. Condition的基本使用

　　 由于Condition可以用来替代wait、notify等方法，所以可以对比着之前写过的线程间通信的代码来看，再来看一下原来那个问题： >有两个线程，子线程先执行10次，然后主线程执行5次，然后再切换到子线程执行10，再主线程执行5次……如此往返执行50次。

之前用wait和notify来实现的，现在用Condition来改写一下，代码如下：

public class ConditionCommunication {

	public static void main(String[] args) {
		Business bussiness = new Business();

		new Thread(new Runnable() {// 开启一个子线程

					@Override
					public void run() {
						for (int i = 1; i <= 50; i++) {

							bussiness.sub(i);
						}

					}
				}).start();

		// main方法主线程
		for (int i = 1; i <= 50; i++) {

			bussiness.main(i);
		}
	}	
}

class Business {

	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition(); //Condition是在具体的lock之上的

	private boolean bShouldSub = true;

	public void sub(int i) {
		lock.lock();
		try {
			while (!bShouldSub) {
				try {
					condition.await(); //用condition来调用await方法
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			for (int j = 1; j <= 10; j++) {
				System.out.println("sub thread sequence of " + j
						+ ", loop of " + i);
			}
			bShouldSub = false;
			condition.signal(); //用condition来发出唤醒信号，唤醒某一个
		} finally {
			lock.unlock();
		}
	}

	public void main(int i) {
		lock.lock();
		try {
			while (bShouldSub) {
				try {
					condition.await(); //用condition来调用await方法
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			for (int j = 1; j <= 10; j++) {
				System.out.println("main thread sequence of " + j
						+ ", loop of " + i);
			}
			bShouldSub = true;
			condition.signal(); //用condition来发出唤醒信号么，唤醒某一个
		} finally {
			lock.unlock();
		}
	}
}

从代码来看，Condition的使用时和Lock一起的，没有Lock就没法使用Condition，因为Condition是通过Lock来new出来的，这种用法很简单，只要掌握了synchronized和wait、notify的使用，完全可以掌握Lock和Condition的使用。

２. Condition的拔高

###** 2.1 缓冲区的阻塞队列** 　　上面使用Lock和Condition来代替synchronized和Object监视器方法实现了两个线程之间的通信，现在再来写个稍微高级点应用：模拟缓冲区的阻塞队列。 什么叫缓冲区呢？举个例子，现在有很多人要发消息，我是中转站，我要帮别人把消息发出去，那么现在我　　就需要做两件事，一件事是接收用户发过来的消息，并按顺序放到缓冲区，另一件事是从缓冲区中按顺序取出用户发过来的消息，并发送出去。 　　现在把这个实际的问题抽象一下：缓冲区即一个数组，我们可以向数组中写入数据，也可以从数组中把数据取走，我要做的两件事就是开启两个线程，一个存数据，一个取数据。但是问题来了，如果缓冲区满了，说明接收的消息太多了，即发送过来的消息太快了，我另一个线程还来不及发完，导致现在缓冲区没地方放了，那么此时就得阻塞存数据这个线程，让其等待；相反，如果我转发的太快，现在缓冲区所有内容都被我发完了，还没有用户发新的消息来，那么此时就得阻塞取数据这个线程。 　　好了，分析完了这个缓冲区的阻塞队列，下面就用Condition技术来实现一下： ```java class Buffer { final Lock lock = new ReentrantLock(); //定义一个锁 final Condition notFull = lock.newCondition(); //定义阻塞队列满了的Condition final Condition notEmpty = lock.newCondition();//定义阻塞队列空了的Condition 
final Object[] items = new Object[10]; //为了下面模拟，设置阻塞队列的大小为10，不要设太大

int putptr, takeptr, count; //数组下标，用来标定位置的

//往队列中存数据
public void put(Object x) throws InterruptedException {
	lock.lock(); //上锁
	try {
		while (count == items.length) {
			System.out.println(Thread.currentThread().getName() + " 被阻塞了，暂时无法存数据！");
			notFull.await();	//如果队列满了，那么阻塞存数据这个线程，等待被唤醒
		}
		//如果没满，按顺序往数组中存
		items[putptr] = x;
		if (++putptr == items.length) //这是到达数组末端的判断，如果到了，再回到始端
			putptr = 0;
		++count;	//消息数量
		System.out.println(Thread.currentThread().getName() + " 存好了值： " + x);
		notEmpty.signal(); //好了，现在队列中有数据了，唤醒队列空的那个线程，可以取数据啦
	} finally {
		lock.unlock(); //放锁
	}
}

//从队列中取数据
public Object take() throws InterruptedException {
	lock.lock(); //上锁
	try {
		while (count == 0) {
			System.out.println(Thread.currentThread().getName() + " 被阻塞了，暂时无法取数据！");
			notEmpty.await();  //如果队列是空，那么阻塞取数据这个线程，等待被唤醒
		}
		//如果没空，按顺序从数组中取
		Object x = items[takeptr];
		if (++takeptr == items.length) //判断是否到达末端，如果到了，再回到始端
			takeptr = 0;
		--count; //消息数量
		System.out.println(Thread.currentThread().getName() + " 取出了值： " + x);
		notFull.signal(); //好了，现在队列中有位置了，唤醒队列满的那个线程，可以存数据啦
		return x;
	} finally {
		lock.unlock(); //放锁
	}
}

}

　　<font size=3>这个程序很经典，我从官方JDK文档中拿出来的，然后加了注释。程序中定义了两个Condition，分别针对两个线程，等待和唤醒分别用不同的Condition来执行，思路很清晰，程序也很健壮。可以考虑一个问题，为啥要用两个Codition呢？之所以这么设计肯定是有原因的，如果用一个Condition，现在假设队列满了，但是有2个线程A和B同时存数据，那么都进入了睡眠，好，现在另一个线程取走一个了，然后唤醒了其中一个线程A，那么A可以存了，存完后，A又唤醒一个线程，如果B被唤醒了，那就出问题了，因为此时队列是满的，B不能存的，B存的话就会覆盖原来还没被取走的值，就因为使用了一个Condition，存和取都用这个Condition来睡眠和唤醒，就乱了套。到这里，就能体会到这个Condition的用武之地了，现在来测试一下上面的阻塞队列的效果：
```java
public class BoundedBuffer {
	
	public static void main(String[] args) {
		
		Buffer buffer = new Buffer();
		
		for(int i = 0; i < 5; i ++) { //开启5个线程往缓冲区存数据
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					try {
						buffer.put(new Random().nextInt(1000)); //随机存数据
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
		
		for(int i = 0; i < 10; i ++) { //开启10个线程从缓冲区中取数据
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					try {
						buffer.take(); //从缓冲区取数据
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
	}
}

我故意只开启5个线程存数据，10个线程取数据，就是想让它出现取数据被阻塞的情况发生，看运行的结果：

Thread-5 被阻塞了，暂时无法取数据！
Thread-10 被阻塞了，暂时无法取数据！
Thread-1 存好了值： 755
Thread-0 存好了值： 206
Thread-2 存好了值： 741
Thread-3 存好了值： 381
Thread-14 取出了值： 755
Thread-4 存好了值： 783
Thread-6 取出了值： 206
Thread-7 取出了值： 741
Thread-8 取出了值： 381
Thread-9 取出了值： 783
Thread-5 被阻塞了，暂时无法取数据！
Thread-11 被阻塞了，暂时无法取数据！
Thread-12 被阻塞了，暂时无法取数据！
Thread-10 被阻塞了，暂时无法取数据！
Thread-13 被阻塞了，暂时无法取数据！

从结果中可以看出，线程5和10抢先执行，发现队列中没有，于是就被阻塞了，睡在那了，直到队列中有新的值存入才可以取，但是它们两运气不好，存的数据又被其他线程给抢先取走了，哈哈……可以多运行几次。如果想要看到存数据被阻塞，可以将取数据的线程设置少一点，这里我就不设了。
###2.2 两个以上线程之间的唤醒
　　还是原来那个题目，现在让三个线程来执行，看一下题目：

有三个线程，子线程1先执行10次，然后子线程2执行10次，然后主线程执行5次，然后再切换到子线程1执行10次，子线程2执行10次，主线程执行5次……如此往返执行50次。

如过不用Condition，还真不好弄，但是用Condition来做的话，就非常方便了，原理很简单，定义三个Condition，子线程1执行完唤醒子线程2，子线程2执行完唤醒主线程，主线程执行完唤醒子线程1。唤醒机制和上面那个缓冲区道理差不多，下面看看代码吧，很容易理解。

public class ThreeConditionCommunication {

	public static void main(String[] args) {
		Business bussiness = new Business();

		new Thread(new Runnable() {// 开启一个子线程

					@Override
					public void run() {
						for (int i = 1; i <= 50; i++) {

							bussiness.sub1(i);
						}

					}
				}).start();
		
		new Thread(new Runnable() {// 开启另一个子线程

			@Override
			public void run() {
				for (int i = 1; i <= 50; i++) {

					bussiness.sub2(i);
				}

			}
		}).start();

		// main方法主线程
		for (int i = 1; i <= 50; i++) {

			bussiness.main(i);
		}
	}

	static class Business {

		Lock lock = new ReentrantLock();
		Condition condition1 = lock.newCondition(); //Condition是在具体的lock之上的
		Condition condition2 = lock.newCondition();
		Condition conditionMain = lock.newCondition();

		private int bShouldSub = 0;

		public void sub1(int i) {
			lock.lock();
			try {
				while (bShouldSub != 0) {
					try {
						condition1.await(); //用condition来调用await方法
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 10; j++) {
					System.out.println("sub1 thread sequence of " + j
							+ ", loop of " + i);
				}
				bShouldSub = 1;
				condition2.signal(); //让线程2执行
			} finally {
				lock.unlock();
			}
		}
		
		public void sub2(int i) {
			lock.lock();
			try {
				while (bShouldSub != 1) {
					try {
						condition2.await(); //用condition来调用await方法
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 10; j++) {
					System.out.println("sub2 thread sequence of " + j
							+ ", loop of " + i);
				}
				bShouldSub = 2;
				conditionMain.signal(); //让主线程执行
			} finally {
				lock.unlock();
			}
		}

		public void main(int i) {
			lock.lock();
			try {
				while (bShouldSub != 2) {
					try {
						conditionMain.await(); //用condition来调用await方法
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for (int j = 1; j <= 5; j++) {
					System.out.println("main thread sequence of " + j
							+ ", loop of " + i);
				}
				bShouldSub = 0;
				condition1.signal(); //让线程1执行
			} finally {
				lock.unlock();
			}
		}
	}
}

代码看似有点长，但是是假象，逻辑非常简单。关于线程中的Condition技术就总结这么多吧。
　　
　　相关阅读：http://blog.csdn.net/column/details/bingfa.html


欢迎大家关注我的公众号：“武哥聊编程”，一个有温度的公众号~
关注回复：资源，可以领取海量优质视频资料
程序员私房菜

—–乐于分享，共同进步！
—–更多文章请看：http://blog.csdn.net/eson_15

武哥聊编程
关注
专栏目录
Java并发之Condition详解
m0_69526086的博客
05-05 374
} finally { //释放锁 readLock.unlock(); } } } 执行结果 1 pool-1-thread-1拿到锁了 2 pool-1-thread-1等待信号 —释放锁-线程等待 t1 3 pool-1-thread-2拿到锁了 4 pool-1-thread-2发出信号 — 唤起线程t2释放锁 5 pool-1-thread-1拿到信号—t1继续执行 如示例所示， 一般都会将Condition对象作为成员变量。当调用await()方法后，当前线程会释放锁并在此等待，而其他
Java多线程之线程并发库条件阻塞Condition的应用
吹雪的专栏
11-19 1030
锁(Lock/synchronized)只能实现互斥不能实现通信，Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能,在等待Condition时,允许发生"虚假唤醒",这通常作为对基础平台语义的让步,对于大多数应用程序,这带来的实际影响很小,因为Condition应该总是在一个循环中被等待,并测试正被等待的状态声明.某个实现可以随意...
java5条件阻塞Condition的应用(十三)
02-09 694
notify和wait必须在sychroized里面写不然会报错 condition就是用来代替wait和notify的 public class ConditionCommunication { /** * @param args * notify和wait必须在sychroized里面写不然会报错 *  *这个condition就是用来代替wait
Condition的应用
学习笔记
01-20 920
JDK原话，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个 C
Java Condition的应用
fujianyuqiang的专栏
08-07 192
class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notFull = lock.newCondition(); final Condition notEmpty = lock.newCondition(); final Object[] items = new O
java并发编程系列之Condition的使用
牛奋lch
12-09 593
Condition是做什么用的了？Condition是用来实现线程间通信的，说到这，可能很多人都想到了wait和notify以及notifyAll，没错，Condition的功能和他们类似，只是功能更强而已，下面我们就来学习一下线程间通过Condition来实现通信。 Condition也是jdk1.5并发包下的一个接口，原型如下： public interface Condition {
Java并发之条件阻塞Condition的应用代码示例
08-28
Java并发之条件阻塞Condition的应用代码示例 Java并发之条件阻塞Condition是Java并发编程中的一种高级同步机制，它允许线程在某个条件下等待或唤醒其他线程。Condition将Object监视器方法（wait、notify和notifyAll...
Java并发编程之Condition源码分析（推荐）
08-26
Java并发编程之Condition源码分析 Condition是Java并发编程中的一种同步机制，用于实现异步通信的同步。Condition主要有两个方法：await()和signal()。await()方法可以阻塞当前线程，并释放锁，而signal()方法可以...
Java并发工具AQS条件队列Condition实现详解
lt_xiaodou的博客
08-23 467
当阻塞唤醒（即从LockSupport.park()放回）之后，且查询到当前线程结点已在锁队列上时，说明此时已有其他线程成功调用了signal()或signalAll()，然后执行争夺锁的操作并把之前的锁状态还原回去，即通过acquireQueued()完成。当有线程在这个Condition上调用了signal时，就会把线程从条件队列转移到它锁关联的那个AQS的锁队列上，并且将它唤醒（此时，阻塞循环中的判断是否在锁队列的条件就会满足，导致跳出循环）。最先开始等待的线程位于头结点，最后等待的线程位于尾结点。
java并发等待条件的实现原理详解
08-28
Java并发等待条件通过`Condition`接口提供了更为精细的控制，使得在多线程环境下能更好地实现同步和协作。了解并熟练掌握`Condition`的使用，有助于设计出高效且复杂的并发程序，提高系统性能。在解决生产者-消费者...
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
通过对`concurrent-programming-master`源码的学习，我们可以更直观地了解上述知识点的实际应用，从而提升自己在Java并发编程方面的技能。这个源码库包含了各种并发编程模式和技巧的实例，是加深理论理解、提升实践...
基于Condition实现阻塞队列
逾越的博客
02-11 7116
public class BoundedQueue { private Object[] items; // 添加的下标，删除的下标和数组当前数量 private int addIndex, removeIndex, count; private Lock lock = new ReentrantLock(); private Condition notEmpty = lock.newCondition(); private Condition notFull = lock.newCondition();
condition的应用举例
weixin_44694708的博客
08-06 198
题目描述： 多线程之间按顺序调用，实现 A-> B -> C 三个线程启动，要求如下： A打印3次，B打印5次，C打印7次 紧接着 A打印3次，B打印5次，C打印7次 … 来3轮 解决办法：ReentrantLock+Condition import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLoc
条件阻塞java__java5条件阻塞Condition的应用
weixin_29528865的博客
02-17 129
wait 和notify 在 synchronized 包含的范围中 必须与synchronized 使用同一个对象可以在一个锁中设定 多个 condition 来执行等待的方法，这样的好处就是能实现多个方法之间的等待执行。例如下面例子 的两个conditionclass BoundedBuffer {final Lock lock = new ReentrantLock();final Cond...
Condition条件阻塞的应用
Mr_zdk的博客
03-04 267
Condition的功能类似传统技术中Obect.wait和Obect.notify的功能/** * 应用场景：三个线程，第一个线程循环10次之后，接着回到第二个线程也循环10次， * 紧接着第三个线程也循环10次，最后又回到第一个线程。如此循环50次！ * */ import java.util.concurrent.locks.Condition; import java.util.co...
条件阻塞java_Java5并发库之条件阻塞Condition的应用
weixin_42164931的博客
02-17 115
锁只能实现互斥，不能实现线程之间的通信(可以参看一个线程间通信的例子http://020618.blog.51cto.com/6098149/1182807)，而Condition可以解决这个问题，即使CPU分给了当前的线程，但是当前的线程可以让出CPU，让其它的相称执行，当前线程暂停，当其它的线程执行完后，在通知当前的线程，这样就实现了线程之间的通信。Java5并发库中的Condition的功能...
线程同步：Condition
五山口老法师
01-04 233
使用Synchronized关键字（synchronized方法或者synchronized代码块）来保证线程间同步，则系统中存在同步监视器（显式或者隐式），可以使用wait()、notify()、notifyAll()来协调线程通信。 但是当我们直接使用Lock对象来保证同步的话，则系统中就不存在同步监视器一说。也就不能使用上述的几个方法。 那怎么办呢? 当使用Lock对象保证同步的话，J...
java集合框架05——ArrayList和LinkedList的区别
热门推荐
武哥聊编程
04-13 10万+
前面已经学习完了List部分的源码，主要是ArrayList和LinkedList两部分内容，这一节主要总结下List部分的内容。 List概括 先来回顾一下List在Collection中的的框架图： 从图中我们可以看出： 1. List是一个接口，它继承与Collection接口，代表有序的队列。 2. AbstractList是一个抽象类，它继承与AbstractColle
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值