多线程锁升级解决方案（JDK1.5及以后）

「爱情、让人受尽委屈。」 2022-07-13 11:12 84阅读 0赞

**在JDK1.5发布之前，我们要进行同步多线程，要使用Synchronized以及 wait notify 等对象，不够形象**

**如以下这个模拟生产和消费的多线程程序**

class Resource { 
        private String name;
        private int count=1;
        private boolean flag=false;
        public synchronized void set(String name)
        {   
            while(flag)//生产一个，消费一个
            try{
       this.wait();}catch(Exception e){}//如果已生产则wait
            this.name=name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
            flag=true;//生产之后转换状态
            this.notifyAll();//唤醒所有进程，再次判断flag，故生产wait
        }
        public synchronized void out()
        {
            while(!flag)
                try{wait();}catch(Exception e){}//如已消费则wait
            System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
            flag=false;//消费之后转换状态
            this.notifyAll();//唤醒所有进程，再次判断flag，故消费wait
        }
    }
    
    class Producer implements Runnable { 
        private Resource res;
        Producer(Resource res)
        {
            this.res=res;
        }
    
        public void run() {
            while(true)
            {
                res.set("+商品+");//run方法调用生产set
            }
        }
    }
    class Consumer implements Runnable { 
        private Resource res;
        Consumer(Resource res)
        {
            this.res=res;
        }
    
        public void run() {
            while(true)
            {
                res.out();//run方法调用消费out
            }
        }
    }
    public class ProducerConsumer { 
    
        public static void main(String[] args) 
        {
            Resource r=new Resource();
            Producer pro=new Producer(r);
            Consumer con=new Consumer(r);
    
            Thread t1=new Thread(pro);//produce线程
            Thread t2=new Thread(pro);//produce线程
            Thread t3=new Thread(con);//consume线程
            Thread t4=new Thread(con);//consume线程
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }

**Synchronized代码执行期间，线程调用对象wait()方法，释放对象锁标志，进入等待状态，并调用notify(), notifyAll()方法通知正在等待的其他线程**

**这样就存在很多问题**

*  如果使用notify，在有些状态下要特定唤醒某个对象，notify是唤醒wait队列第一条线程，不确定性很大
 *  如果使用notifyAll，又浪费资源
 *  synchronized一个锁只能绑定一个对象，要依靠锁去区分对象，若加一嵌套就死锁了

**1.5之后的Lock和Condition就很好地解决了这个问题**

**将上述代码改写之后如下**

class Resource2
    {
        private String name;
        private int count=1;
        private boolean flag=false;
        private Lock lock=new ReentrantLock();
    
        private Condition condition_pro=lock.newCondition();//定义一个produce的condition
        private Condition condition_con=lock.newCondition();//定义一个consume的condition
        public  void set(String name)throws InterruptedException
        {   
            lock.lock();
            try {
                while(flag)//判断状态
                    condition_pro.await();//如果以生产则wait
                this.name=name+"--"+count++;
                System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
                flag=true;//转换状态
                condition_con.signal();//在produce里面指定唤醒consume
            } 
            catch (Exception e) {
            }
            finally
            {
                lock.unlock();//用finally确保unlock，使资源得到释放
            }
    
    
        }
        public  void out()throws InterruptedException
        {
            lock.lock();
            try {
                while(!flag)
                    condition_con.await();
                System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
                flag=false;
                condition_pro.signal();//在consume里面指定唤醒produce
            } catch (Exception e) {
    
            }
            finally
            {
                lock.unlock();
            }
    
        }
    }
    
    class Producer2 implements Runnable
    {
        private Resource res;
        Producer2(Resource res)
        {
            this.res=res;
        }
    
        public void run() {
            while(true)
            {
                res.set("+商品+");
            }
        }
    }
    class Consumer2 implements Runnable
    {
        private Resource res;
        Consumer2(Resource res)
        {
            this.res=res;
        }
    
        public void run() {
            while(true)
            {
                res.out();
            }
        }
    }
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ProducerConsumer2 {
    
        public static void main(String[] args) 
        {
            Resource r=new Resource();
            Producer pro=new Producer(r);
            Consumer con=new Consumer(r);
    
            Thread t1=new Thread(pro);
            Thread t2=new Thread(pro);
            Thread t3=new Thread(con);
            Thread t4=new Thread(con);
            t1.start();
            t2.start();
            t3.start();
            t4.start();
    
        }
    
    }

*  将同步Synchronized替换成显式的Lock操作以及显式的锁对象的等待唤醒操作机制
 *  一个锁可对应多个condition，预防Synchronized使用两个notify，两个锁导致形成死锁
 *  将Object中的wait，notify，notifyall，封装成Condition对象 该对象可以通过Lock锁进行获取
 *  该示例中，实现了本方只唤醒对方的操作。