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

柔情只为你懂 2022-06-07 05:20 263阅读 0赞

还是之前的生产者消费者问题，这里通过这个问题介绍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之后的写法，但是并没有实现了优化，不该被唤醒的线程依然会被唤醒，优化方法会在之后介绍