JAVA 线程间通信 -生产者消费者JDK5.0升级版

/*
	JDK1.5中提供了多线程升级解决方案
	将同步Synchronized替换成现实Lock操作
	将Object中的wait，notify, notifyAll,替换成了Condition对象
	该对象可以是Lock锁，进行获取
*/

import java.util.concurrent.locks.*;

class Res
{
	private int count=0;
	private String name;

	private	boolean flag = false;

	private Lock lock = new ReentrantLock();//申请锁

	private Condition condition_pro = lock.newCondition();//控制生产者的 唤醒和等待
	private Condition condition_con = lock.newCondition();//控制消费者的 唤醒和等待		


	public void set(String name)throws InterruptedException
	{	
		lock.lock();//上锁
		try
		{
			while(flag)
				condition_pro.await();//生产者等待
			this.name = name+ " "+ (++count);
			System.out.println(Thread.currentThread().getName() + "--生产者--" + this.name);
		
			flag = true;
			condition_con.signal();//消费者唤醒
	
		}
		finally
		{
			lock.unlock();//解锁
		}
	}

	public void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();

			System.out.println(Thread.currentThread().getName() + "--消费者----" + this.name);

			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
	
}

class Producer implements Runnable 
{
	Res r = new Res();

	Producer(Res r)
	{
		this.r = r;
	}
		
	public void run()
	{
		while(true)
			try
			{
				r.set("商品");
			}
			catch(InterruptedException e) 
			{}
	}
}


class Consumer implements Runnable
{
	Res r = new Res();

	Consumer(Res r)
	{
		this.r = r;
	}
	
	public void run()
	{
		while(true)
			try
			{
				r.out();
			}
			catch(InterruptedException e) 
			{}
	}

}

class TestDemo
{
	public static void main(String []args)
	{
		Res r = new Res();

		Producer p = new Producer(r);
		Consumer c = new Consumer(r);

		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		Thread t3 = new Thread(p);
		Thread t4 = new Thread(c);


		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}