Condition 与wait和notify

ondition可以实现多路Condition,notify只能通知随机的一个

如:ABC三个线程分别去处理一件事物,规则是A处理完通知B ,B处理完通知C,C通知A;如果使用notrfy无法做法这一点,所以我们可以使用Condition来new出来ABC三个Condition对象,来特定指明哪个对象await哪个对象single;

如:先放鸡蛋、拿鸡蛋、吃鸡蛋

public class EggServlet {
	private Lock lock = new ReentrantLock();
	Condition put = lock.newCondition();
	Condition get = lock.newCondition();
	Condition eatlock = lock.newCondition();
	int num = 0;
	int eat = 0;

	public void putEgg() {
		lock.lock();
		try {
			while (num!=0) {
				try {
					put.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			num++;
			System.out.println("放入了鸡蛋" + num);
			get.signal();
		} catch (Exception ep) {
           System.out.println(ep.toString());
		} finally {
			lock.unlock();
		}
	}

	public void getEgg() {
      lock.lock();
      while(num==0){
    	  try {
			get.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
      }
      System.out.println("拿到了鸡蛋" + num);
		num--;
		eat++;
		eatlock.signal();
		lock.unlock();

	}

	public void eatEgg() {
		lock.lock();
		while(eat==0){
			try {
				eatlock.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("吃鸡蛋" + num);
		System.out.println("=====================");
		eat--;
		put.signal();
		lock.unlock();
	}
}

public class TestClient {

	public static void main(String[] args) {
		EggServlet egg = new EggServlet ();
<span style="white-space:pre">		</span>Thread t1 =new Thread(new PutThead(egg));
<span style="white-space:pre">		</span>Thread t2 = new Thread(new GetThead(egg));
<span style="white-space:pre">		</span>Thread t3 =new Thread(new EatThead(egg));
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>/*t1.start();
<span style="white-space:pre">		</span>t2.start();
<span style="white-space:pre">		</span>t3.start();*/
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>ExecutorService pool =Executors.newCachedThreadPool();
<span style="white-space:pre">		</span>pool.execute(t1);
<span style="white-space:pre">		</span>pool.execute(t2);
<span style="white-space:pre">		</span>pool.execute(t3);
	}

}

class PutThead implements Runnable {
	private EggServlet egg;

	public PutThead(EggServlet egg) {
		this.egg = egg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			egg.putEgg();
		}

	}
}

class GetThead implements Runnable {
	private EggServlet egg;

	public GetThead(EggServlet egg) {
		this.egg = egg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			egg.getEgg();
		}

	}
}

class EatThead implements Runnable {
	private EggServlet egg;

	public EatThead(EggServlet egg) {
		this.egg = egg;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			egg.eatEgg();
		}

	}
}
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
放入了鸡蛋1
拿到了鸡蛋1
吃鸡蛋0
=====================
时间: 2024-08-05 13:44:07

Condition 与wait和notify的相关文章

Lock+Condition 相对于 wait+notify 的一个优势案例分析

问题的描述 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到打印到45. wait+notify实现: package com.tonyluis; public class NumberPrintDemo { static int n = 1; static int state = 0; public static void

14 线程间协作的两种方式:wait、notify、notifyAll和Condition

原文链接:http://www.cnblogs.com/dolphin0520/p/3920385.html 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权.因为生产者如果不释放对临界资源的占用权,那么消费者就无法消费队列中的商品,就不会让队列有空间,那么生产者就会一直无限等待下去.因此,一般情况下,当队列满时,会让生产者

Linux组件封装(二)中条件变量Condition的封装

条件变量主要用于实现线程之间的协作关系. pthread_cond_t常用的操作有: int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr); int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); int pthread_cond_wait(pthread_cond

Java多线程之ReentrantLock与Condition

一.ReentrantLock 类 1.1 什么是reentrantlock java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象,它允许把锁定的实现作为 Java 类,而不是作为语言的特性来实现.这就为 Lock 的多种实现留下了空间,各种实现可能有不同的调度算法.性能特性或者锁定语义. ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义,但是添加了类似锁投票.定时锁等候和可中断锁等候的一些特性.此外

python多线程之Condition(条件变量)

#!/usr/bin/env python # -*- coding: utf-8 -*- from threading import Thread, Condition import time items = [] condition = Condition() class Consumer(Thread): def __init__(self): Thread.__init__(self) def consume(self): global condition global items co

0714-----C++Primer听课笔记----------封装mutex,thread,condition等

1.封装Mutex 1.1 封装前先总结一下常用的mutex操作有: pthread_mutex_init(&mutex, NULL ); //初始化一个互斥锁 pthread_mutex_destroy(&mutex); //销毁一个互斥锁 pthread_mutex_lock(&mutex); //上锁 pthread_mutex_unlock(&mutex);// 解锁 1.2 用类把这下常用函数进行封装,代码如下,注意编译时不要忘记链接pthread. #ifnde

java 多线程之ReentrantLock与condition

参考链接:https://blog.csdn.net/vernonzheng/article/details/8288251 ReentrantLock 类 1.1 什么是reentrantlock java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象,它允许把锁定的实现作为 Java 类,而不是作为语言的特性来实现.这就为 Lock 的多种实现留下了空间,各种实现可能有不同的调度算法.性能特性或者锁定语义. ReentrantLock 类实现了 Lock ,

wait、notify应用场景(生产者-消费者模式)

Java实现生产者消费者的方式有:wait && notify.BlockingQueue.Lock && Condition等 wait.notify注意事项:(1)可以使用wait()和notify()方法在Java中实现线程间通信.不只是一个或两个线程,而是多个线程可以使用这些方法相互通信.(2)在synchronized方法或synchronized块中调用wait(),notify()和notifyAll()方法,否则JVM将抛出IllegalMonitorSta

java并发系列(二)-----线程之间的协作(wait、notify、join、CountDownLatch、CyclicBarrier)

在java中,线程之间的切换是由操作系统说了算的,操作系统会给每个线程分配一个时间片,在时间片到期之后,线程让出cpu资源,由其他线程一起抢夺,那么如果开发想自己去在一定程度上(因为没办法100%控制它)让线程之间互相协作.通信,有哪些方式呢? wait.notify.notifyAll 1.void wait( ) 导致当前的线程等待,直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法 2.void wait(long timeout) 导致当前的线程等待,直到