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

还是之前的生产者消费者问题，这里通过这个问题介绍jdk1.5中的Lock接口和Condition接口

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



*/
//描述产品
import java.util.concurrent.locks.*;
class Product{
    private String name;
    private int count;
    private boolean flag;

    //1：创建一把锁
    private Lock lock = new ReentrantLock();//父类引用指向子类对象，多态

    //得到和锁绑定的Condition对象
    private Condition con = lock.newCondition();

    //生产产品的功能
    public void produce(String name){
        lock.lock();//获取锁
        try{
            while(flag){
                //IllegalMonitorStateException
                try{con.await();}catch(InterruptedException e){e.printStackTrace();}
            }
            this.name = name+"..."+count;
            System.out.println(Thread.currentThread().getName()+"生产了..."+this.name);
            count++;
            flag = true;
            //唤醒所有lock锁上的线程
            con.signalAll();
        }
        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;
            con.signalAll();
        }
        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 test{
    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();
    }
}

这里只是将写法改为了jdk1.5之后的写法，但是并没有实现了优化，不该被唤醒的线程依然会被唤醒，优化方法会在之后介绍