Lock锁，一次唤醒所有线程低性能的问题

/*
jdk1.5多线程的实现方式：
jdk1.5之前对锁的操作是隐式的
synchronized(对象)//获取锁
{

}//释放锁

jdk1.5对锁的操作是显式的:
有一个描述锁的Lock接口，也就是把锁面向对象了
使用Lock接口的子类ReentrantLock创建一把锁

使用Lock替代同步代码块的方式：
1：使用Lock接口的子类ReentrantLock创建一把锁
2：把之前写在同步代码块中的代码写在lock()和unlock()之间

用Lock替代同步代码块之后出现了IllegalMonitorStateException(无效的监视器状态异常)
因为wait(),notifyAll()必须用在同步中，而同步被Lock替代了，所以异常

jdk1.5对唤醒等待方法也进行了单独的描述，描述的接口是Condition
唤醒等待方法必须结合着来使用，所以使用Lock的newCondition()方法来获取和锁绑定
Condition对象

*/

//使用jdk1.5 多线程的实现方式 解决一次唤醒所有线程性能低的问题
import java.util.concurrent.locks.*;
class Product
{
private String name;
private int count;
private boolean flag;

//创建一把锁
private Lock lock = new ReentrantLock();

//得到和锁绑定的Condition对象，控制生产线程的唤醒和等待
private Condition pro = lock.newCondition();

//得到和锁绑定的Condition对象，控制消费线程的唤醒和等待
private Condition con = lock.newCondition();

//生产产品的功能
public  void produce(String name)
{
lock.lock();//获取锁
try{
while(flag)
{
try{pro.await();}catch(InterruptedException e){e.printStackTrace();}
}
this.name = name+"..."+count;
System.out.println(Thread.currentThread().getName()+"生产了....."+this.name);
count++;
flag = true;
con.signal();
}
finally
{
lock.unlock();//释放锁
}
}
//消费产品的功能
public void consume()
{
lock.lock();
try{
while(!flag)
{
try{con.await();}catch(InterruptedException e){e.printStackTrace();}
}
System.out.println(Thread.currentThread().getName()+"......消费了....."+name);
flag = false;
pro.signal();
}
finally
{
lock.unlock();
}
}
}

//生产任务
class Producer implements Runnable
{
private Product pro;
public Producer(Product pro)
{
this.pro =pro;
}
public void run()
{
while(true)
{
pro.produce("笔记本");
}
}
}
//消费任务
class Consumer implements Runnable
{
private Product pro;
public Consumer(Product pro)
{
this.pro =pro;
}
public void run()
{
while(true)
{
pro.consume();
}
}
}
class Demo5
{
public static void main(String[] args)
{
Product pro = new Product();

Producer producer =new Producer(pro);
Consumer consumer = new Consumer(pro);

Thread t0 = new Thread(producer);
Thread t1 = new Thread(producer);

Thread t2 =  new Thread(consumer);
Thread t3 =  new Thread(consumer);

t0.start();
t1.start();

t2.start();
t3.start();

}
}