Java并发编程——使用Condition的总结笔记

浅浅的花香味﹌ 2023-06-19 06:49 6阅读 0赞

#### 前提知识 ####

在讲解Condition之前有必要了解一下Lock和Synchronized，以及Synchronized同步代码块中使用的wait()、notify()、notifyAll()方法

###### 1. Lock和Synchronized ######

*  Synchronized是Java的一个关键字，也就是Java语言内置的特性，如果一个代码块或者方法被Synchronized修饰，那同一时刻只能有一个线程进入代码块或者方法（获得锁），其他线程便只能一直等待，等待获取锁的线程释放锁。
 *  Lock不是Java语言内置的，它是一个接口，ReentrantLock是它的一个实现类。
 *  Synchronized是在JVM层面上实现的，如果代码执行出现异常,JVM会自动释放锁，但是Lock不行，要保证锁一定会被释放，就必须在finally\{\}中使用unlock()方法(手动释放)。
 *  Synchronized是非公平锁，而Lock可以实现公平锁和非公平锁（默认非公平锁，构造方法传一个参数，true或者false）。
 *  在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetarntLock，但是在很激烈的情况下，synchronized的性能会下降几十倍。

###### 2.wait()、notify()、notifyAll() ######

*  它们必须使用在Synchronized代码块中
 *  wait()方法释放锁，进入等待状态（需要被唤醒），唤醒之后并竞争获得锁之后继续执行下面的代码
 *  notify()唤醒等待中的一个线程（随机），由等待状态进入阻塞状态（唤醒之后不一定就能获得锁，还需要竞争锁）
 *  notifyAll()唤醒等待中的所有线程，由等待状态进入阻塞状态（唤醒之后不一定就能获得锁，还需要竞争锁）

#### Condition ####

*  Lock和Condition配合使用就相当于实现Synchronized中wait()、notify()、notifyAll()功能
 *  Condition中的await()方法相当于Object的wait()方法，  
    Condition中的signal()方法相当于Object的notify()方法，  
    Condition中的signalAll()相当于Object的notifyAll()方法。
 *  Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。  
    ![在这里插入图片描述][20191204211619777.png]
 *  例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒"读线程"；当从缓冲区读出数据之后，唤醒"写线程"；并且当缓冲区满的时候，"写线程"需要等待；当缓冲区为空时，“读线程"需要等待。  
    如果采用Object类中的wait(), notify(), notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒"读线程"时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程”，而只能通过notifyAll唤醒所有线程(但是notifyAll无法区分唤醒的线程是读线程，还是写线程)。 但是，通过Condition，就能明确的指定唤醒读线程。

#### Condition简单应用代码 ####

package day20191204;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/4 * @Description: Condition简单应用 */
    public class ConditionTest { 
    
        /** * condition.await() 释放锁，进入等待状态（因为要释放对象锁，所以只能应用于lock加锁内部） * condition.signal() 唤醒在该condition上的一个等待线程（随机） */
        public static void main(String[] args) { 
            ReentrantLock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
    
            new Thread(() -> { 
                try { 
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + "\t抢占到锁");
                    long before = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName() + "\t进入等待睡眠");
    
                    condition.await();
    
    
                     /* 释放对象锁，进入等待状态，要是重新获得锁，即直接从此处往下执行 */
                    long wait = System.currentTimeMillis() - before;
                    System.out.println(Thread.currentThread().getName() + "\t被唤醒，睡了:" + wait + "毫秒");
                } catch (Exception e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            }, "AA").start();
    
    
            new Thread(() -> { 
                try { 
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + "\t抢占到锁");
                    Thread.sleep(3000);
    
                    // 唤醒condition上等待的线程
                    /* 唤醒等待的线程，并不是说他就会立刻获得锁进入运行状态 唤醒只是表明，它有了竞争锁的”资格“，即进入阻塞状态 */
                    condition.signal();
    
    
    
                    /* 这里虽然唤醒了等待线程，但是没有释放锁，还是会先把自己的业务逻辑执行完毕，再释放锁 */
    
                    System.out.println("还执不执行");
                    Thread.sleep(3000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            }, "BB").start();
    
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]  
几点注意：

![在这里插入图片描述][2019120421284882.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 1]

#### Condition实现三个线程按顺序执行代码 ####

package day20191204;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    class Work { 
    
        // 用于控制线程顺序访问的变量
        private int mark = 3;
        private Lock lock = new ReentrantLock();
        // 三个Condition，用于指定情况的等待和指定的唤醒
        private Condition condition1 = lock.newCondition();
        private Condition condition2 = lock.newCondition();
        private Condition condition3 = lock.newCondition();
    
    
        public void workA() { 
    
            try { 
                lock.lock();
    
                while (mark != 1) { 
                    condition1.await();
                }
                mark = 3;
                System.out.println(Thread.currentThread().getName());
    
                condition3.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void workB() { 
    
            try { 
                lock.lock();
    
                while (mark != 2) { 
                    condition2.await();
                }
                mark = 1;
                System.out.println(Thread.currentThread().getName());
    
                condition1.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void workC() { 
    
            try { 
                lock.lock();
    
                while (mark != 3) { 
                    condition3.await();
                }
                mark = 2;
                System.out.println(Thread.currentThread().getName());
    
                condition2.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
    }
    
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/4 * @Description: Condition实现三个线程按顺序执行，CC-BB-AA，执行5次 */
    public class ConditionSortTest { 
    
        public static void main(String[] args) { 
    
            Work work = new Work();
    
            new Thread(() -> { 
                for (int i = 1; i <= 5; i++) { 
                    work.workA();
                }
            }, "AA").start();
    
            new Thread(() -> { 
                for (int i = 1; i <= 5; i++) { 
                    work.workB();
                }
            }, "BB").start();
    
            new Thread(() -> { 
                for (int i = 1; i <= 5; i++) { 
                    work.workC();
                }
            }, "CC").start();
        }
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 2]  
实现逻辑并不难，仔细看看都是能够看得懂的；主要就是体现Condition的一大特色，能够更加精细的控制多线程的休眠与唤醒（指定具体的线程的休眠和唤醒）

#### Condition实现简易生产者消费者模式代码（生产一个、消费一个，严格控制，不存在过度生产、过度消费） ####

package day20191204;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    class Resources { 
        private int num = 0;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        /** * 生产者 */
        public void production() { 
    
            try { 
                lock.lock();
    
                /** * 为什么是while，不是if？？？ * 因为在有多个生产者和多个消费者的情况下，如果使用if，会出现过度生产和过度消费的情况 * 比如消费者A执行完毕，num=0，它唤醒的等待线程中，消费者B获得了锁（而且这里的消费者B之前执行过，但是因为num!=0，进入了等待状态） * 消费者B继续执行，因为是if不是while，不会再次判断num是否等于0，而继续执行下面的代码，出现了过度消费的情况。。 */
    
                while (num != 0) { 
                    condition.await();
                }
                num++;
                System.out.println(Thread.currentThread().getName() + "\t" + num);
    
                condition.signalAll();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        /** * 消费者 */
        public void consume() { 
    
            try { 
                lock.lock();
    
                while (num == 0) { 
                    condition.await();
                }
                num--;
                System.out.println(Thread.currentThread().getName() + "\t" + num);
    
                condition.signalAll();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    }
    
    
    /** * @Author: xiaoshijiu * @Date: 2019/12/4 * @Description: 利用Condition实现简单的生产者消费者模式 */
    public class ProductionConsumeDesign { 
        public static void main(String[] args) { 
    
            Resources resources = new Resources();
    
            new Thread(() -> { 
                for (int i = 1; i <= 10; i++) { 
                    resources.production();
                }
            }, "生产者").start();
    
    
            new Thread(() -> { 
                for (int i = 1; i <= 10; i++) { 
                    resources.consume();
                }
            }, "消费者").start();
        }
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 3]  
有一个注意事项就是  
![在这里插入图片描述][20191204215859152.png]  
这两个地方的while不能使用if吗？

答案：在只有一个生产者和一个消费者的情况下，while和if都可以；但是在有多个生产者和多个消费者的情况下，避免过度消费或者过度生产，只能使用while  
![在这里插入图片描述][20191204215942792.png]  
这也是JDK官方文档推荐的，看Object的wait()方法介绍  
![在这里插入图片描述][20191204222700583.png]  
should always be used in a loop  
应该总是被使用在一个循环里面

Condition的await()方法也是类似！！！

[20191204211619777.png]: https://img-blog.csdnimg.cn/20191204211619777.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191204212734467.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70
[2019120421284882.png]: https://img-blog.csdnimg.cn/2019120421284882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191204213002796.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191204214844978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191204215829729.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoaWppdWppdTMz,size_16,color_FFFFFF,t_70
[20191204215859152.png]: https://img-blog.csdnimg.cn/20191204215859152.png
[20191204215942792.png]: https://img-blog.csdnimg.cn/20191204215942792.png
[20191204222700583.png]: https://img-blog.csdnimg.cn/20191204222700583.png