jdk1.5多线程Lock接口及Condition接口

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

} //释放锁

jdk1.5锁的操作是显示的：在包java.util.concurrent.locks中含有多线程实现方式相关的接口和类。
有一个描述锁的Lock接口，也就是把锁面向对象了

使用Lock接口的子类ReentrantLock创建一把锁
Lock lock = new ReentrantLock();
使用Lock替代同步代码块的方式：
1：创建一把锁
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   //为了保证锁必须被释放掉，使用try{...}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()+"---消费了---"+this.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 Demo
 {
     public static void main(String[] args)
     {
         Product pro = new Product();

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

         new Thread(producer,"生产线01").start();
         new Thread(consumer,"消费者01").start();
         new Thread(producer,"生产线02").start();
         new Thread(consumer,"消费者02").start();
     }
 }