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

关于Lock锁，我们简单说一下

Lock锁的包是java.util.concurrent.locks.*;

/*
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对象

*/

对于具体的lock锁的应用就先不说了，下面直接在如何利用Lock锁以及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();


    }
}