多线程的等待唤醒(使用监视器)

/*
在jdk1.5版本之后，
出现了一些新的特性，将原理的线程进行了改良。

在java.util.concurrent.locks包中提供了一个接口Lock。替代了synchronized。

synchronized。使用的是锁操作是隐式的。

Lock接口，使用的锁操作是显示的。
由两个方法来完成：
lock():获取锁。
unlock():释放锁。


还有一个对象，Condition.
该对象的出现替代了Object中的wait notify notifyAll这些操作监视器的方法。

替代后的方式：await  signal  signalAll.





接下来，把下列代码替换成JDK1.5版本只有的新对象。



新功能最大好处，就是在一个Lock锁上，可以添加多组监视器对象。

这样就可以实现本方只唤醒对方的线程



锁,是同步的机制.通过锁来控制同步.监视器是用于同步中对象的操作.
比如wait,notify  notifyAll.每一组监视器方法对应一个锁.
到了jdk1.5以后，将监视器的方式从Object中，封装到了Condition对象中，
每一个锁lock，可以对应多组监视器对象，这就可以实现本方只唤醒对方的操作。


*/
import java.util.concurrent.locks.*;
class Res
{
	private String name;
	private int count  = 0;
	private boolean b = false;

	//定义一个锁。
	Lock lock = new ReentrantLock();

	//通过指定的锁，创建了一个该锁上可以使用了监视器对象。
	Condition proCon = lock.newCondition();

	//升级后的lock可以对应多组监视器对象。
	Condition cusCon = lock.newCondition();


	public void set(String name)
	{
		//获取锁。
		lock.lock();
		try
		{	
			while(b)
				proCon.await();
			this.name = name+"--------"+count;
			count++;
			System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
			b = true;
			cusCon.signal();
		}
		catch(InterruptedException e)
		{
		
		}
		finally
		{
			//释放锁
			lock.unlock();
		}


	}


	public void out()
	{
		lock.lock();
		try
		{
			while(!b)
				cusCon.await();
			System.out.println(Thread.currentThread().getName()+"----消费者---"+this.name);
			b = false;
			proCon.signal();

		}
		catch (InterruptedException e)
		{
		}
		finally
		{
			lock.unlock();
		}
	}
	
}


class Pro implements Runnable
{
	private Res r;
	Pro(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.set("产品");
		}
	}
}
class Cus implements Runnable
{
	private Res r;
	Cus(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}



class ProCusDemo2 
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		Pro p = new Pro(r);
		Cus c = new Cus(r);

		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		//t1,t2都是生产者。
		//t3,t4都是消费者。
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}