java中condition使用

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

　　条件（也称为条件队列 或条件变量）为线程提供了一个含义，以便在某个状态条件现在可能为 true 的另一个线程通知它之前，一直挂起该线程（即让其“等待”）。因为访问此共享状态信息发生在不同的线程中，所以它必须受保护，因此要将某种形式的锁与该条件相关联。等待提供一个条件的主要属性是：以原子方式 释放相关的锁，并挂起当前线程，就像 Object.wait 做的那样。

　　Condition 实例实质上被绑定到一个锁上。要为特定Lock实例获得 Condition 实例，请使用其 newCondition（）方法。作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个Condition实例来做到这一点。

1. 定义消息管道

package com.java.test;

import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 存储 生产者消息的通道
 * @author jiajie
 *
 */
public class MiddlewareChannel2 {
	public int init_capacity=0;//初始存储  
	public int max_capacity=20;//最大存储 最大容量值
	
	private Lock lock = new ReentrantLock();
	private Condition conumer = lock.newCondition();
	private Condition producer = lock.newCondition();
	
	/**
	 * 		  消息端产生消息
	 * 		  
	 * @param message
	 */
	public void send() {
		//拿到锁
		try {
			lock.lock();
			//判断通道是否已满
			if(init_capacity > max_capacity) {   //已满
				try {
					System.out.println("库存已满,生产者等待发送信息...");
					//生产者  等待发送消息
					producer.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}else {
				
				//通知消费者 消费消息
				System.out.println(Thread.currentThread().getName()+":生产消息" +"库存容量:"+(++init_capacity));
				//唤醒所有消费者
				conumer.signalAll();
			}
			
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}finally {
			lock.unlock();
		}
		
		
		
		
	}
	
	/**
	 * 消息端 消费消息
	 */
	public void accept() {
		
		try {
			lock.lock();
			
			//判断通道是否有消息
			if (init_capacity>0) {  //通道有消息
				 //弹出消息
				 System.out.println(Thread.currentThread().getName()+":消费消息:"+" 库存容量:"+(--init_capacity));
				//消费完唤醒生产者 生产消息
			     producer.signalAll();
			}else {           //通道无消息
				try {
					System.out.println("库存不足,等待生产者生产消息...");
					//等待消费
					conumer.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

}

2发送端

package com.java.test;

/**
 * 生产者
 * @author jiajie
 *
 */
public class Producer implements Runnable{
	private MiddlewareChannel middlewareChannel;
	private String threadName;
	private String message;
	

	/**
	 * 构造通道类
	 * @param middlewareChannel
	 */
	public Producer(MiddlewareChannel middlewareChannel) {
		this.middlewareChannel = middlewareChannel;
	}

	/**
	 * 生产消息
	 */
	@Override
	public void run() {
		// TODO Auto-generated method stub
//		while (true) {
//			System.out.println(Thread.currentThread().getName());
//			middlewareChannel.send(message);
//		}
		
		for (int i = 0; i < 20; i++) {
//			System.out.println(Thread.currentThread().getName());
			middlewareChannel.send();
		}
	}
	
	
}

2.消费端

package com.java.test;

import javax.sound.midi.MidiChannel;

/**
 * 消费者
 * @author jiajie
 *
 */
public class Conumer implements Runnable{
	private MiddlewareChannel middlewareChannel;

	public Conumer(MiddlewareChannel middlewareChannel) {
		
		this.middlewareChannel = middlewareChannel;
	
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
//			System.out.println(Thread.currentThread().getName());
			middlewareChannel.accept();
		}
	
	}
	
}

3.测试

package com.java.test;

public class ClientTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建消息通道
		MiddlewareChannel middlewareChannel = new MiddlewareChannel();
		
		
		//创建消息消费者
		Conumer conumer1 = new Conumer(middlewareChannel);
		new Thread(conumer1,"消费者1").start();
		
//		//创建消息消费者
//		Conumer conumer2 = new Conumer(middlewareChannel);
//		new Thread(conumer2, "消费者2").start();
		
		//创建消息生产者1
		Producer producer1 = new Producer(middlewareChannel);
		new Thread(producer1,"生产者1").start();
		
//		//创建消息生产者2
//		Producer producer2 = new Producer(middlewareChannel, "我爱加班");
//		new Thread(producer2,"生产者2").start();
		
		
	}

}