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();
    }
}