java多线程中的生产者消费者模式实现线程间的通信

本实例是一个简单的：单生者vs单消费者

1.生产者类：

package p_t_test;

/**
 * wait/notify变形模式：生产者消费者模式实现进程间通信
 * 
 * 生产者
 * @author lxb
 *
 */
public class P {
	
	private String lock;
	public P(String lock){
		this.lock = lock;
	}
	
	public void setValue(){
		
		try{
			synchronized (lock) {
				
				//如果不为空，生产者处于等待状态
				if(!ValueObject.value.equals("")){
					System.out.println("我是消费者，此时缓冲池中有数据，我正在等待这个池没有数据被消费者用，它用完之后，我就放新的数据 ");
					lock.wait();
				}
				
				String value = System.currentTimeMillis() + "_"+System.nanoTime();
				System.out.println("我放的 的值是："+value);
				lock.notify();
				
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}

}

2.生产者线程：

package p_t_test;

/**
 * 生产者线程
 * @author lxb
 *
 */
public class ThreadP extends Thread{
	
	private P p;
	
	public ThreadP(P p){
		this.p = p;
	}
	
	public void run(){
		
		//生产者不停的向缓冲池中存放数据
		while(true){
			p.setValue();
		}
	}

}

3.消费者类：

package p_t_test;

/**
 * 消费者类
 * @author lxb
 *
 */
public class C {

	private String lock;
	
	public C(String lock){
		this.lock = lock;
	}
	
	public void getValue(){
		try{
			synchronized (lock) {
				//当没有值可供消费者使用时，使用消费者的线程处于等待状态
				if(ValueObject.value.equals("")){
					System.out.println("我是消费者，你妹生产者为毛还不放值 ，等了半天了，老子急用:");
					lock.wait();
				}
				System.out.println("消费者获取到的值是:"+ValueObject.value);
				
				ValueObject.value = "";	//消费者取完值之后，将当前值置空
				lock.notify();          //唤醒生产者可以向缓冲池中存放数据了
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
}

4.消费者线程：

package p_t_test;

/**
 * 消费者线程
 * @author lxb
 *
 */
public class ThreadC extends Thread{

	private C c;
	
	public ThreadC(C c){
		
		this.c = c;
		
	}
	
	public void run(){
		
		/**
		 * 消费者不停的从缓冲池中取数据
		 */
		while(true){
			c.getValue();
		}
	}
}

5.数据缓冲池：

package p_t_test;

public class ValueObject {

	public static String value="";
}

6.测试类：

package p_t_test;

public class TestClient {

	public static void main(String[] args) {

		String lock = new String(""); // 创建对象锁

		P p = new P(lock);

		C r = new C(lock);
		
		ThreadP pThread = new ThreadP(p);
		
		ThreadC cThread = new ThreadC(r);
		
		pThread.start();
		cThread.start();
	}
}