volatile

  1. 两个线程之间互相通信的问题
  2. 1A2B3C4D的问题（公开课）—->之后会讲

image.png

  1. 第一个线程完成到某个位置的时候，要通知某个线程
  2. 一边加add一边检测

第一种写法

  1. /**
  2.  * 曾经的面试题：（淘宝？）
  3.  * 实现一个容器，提供两个方法，add，size
  4.  * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
  5.  * 
  6.  * 分析下面这个程序，能完成这个功能吗？
  7.  * @author mashibing
  8.  */
  9. package com.mashibing.juc.c_020_01_Interview;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.concurrent.TimeUnit;
  16. public class T01_WithoutVolatile {
  18.     List lists = new ArrayList();
  20.     public void add(Object o) {
  21.         lists.add(o);
  22.     }
  24.     public int size() {
  25.         return lists.size();
  26.     }
  28.     public static void main(String[] args) {
  29.         T01_WithoutVolatile c = new T01_WithoutVolatile();
  31.         new Thread(() -> {
  32.             for(int i=0; i<10; i++) {
  33.                 c.add(new Object());
  34.                 System.out.println("add " + i);
  36.                 try {
  37.                     TimeUnit.SECONDS.sleep(1);
  38.                 } catch (InterruptedException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.         }, "t1").start();
  44.         new Thread(() -> {
  45.             while(true) {
  46.                 if(c.size() == 5) {
  47.                     break;
  48.                 }
  49.             }
  50.             System.out.println("t2 结束");
  51.         }, "t2").start();
  52.     }
  53. }

第二种写法

  1. 第一种写法不能满足需求—->不行、有问题（同步的角度）
    1. ArrayList不是线程安全的—->要用同步容器（加元素和size的更新必须得是同步的，参照c问题—->d也能够实现？）
    2. 要保证线程之间的可见性
    3. 第二个线程读的时候，可能读到的size是之后的，因为是先加进去再更新size，有可能在这之间被打断
    4. 没加同步—->要在add和size方法上加synchronized？不对？？？
    5. 第二个线程没有检测到size==5，因为线程之间不可见的原因—->第一个线程变了的话，第二个线程不能马上看见—->加volatile？……
  2. 既然是线程不安全的容器，那么为什么不会出现ConcurrentModificationException的异常？？？
  3. 什么时候会出现ConcurrentModificationException，foreach中只能遍历访问元素，不能修改元素？？？
  4. 同时修改、读取会出现ConcurrentModificationException？modcount在读取的时候会++？
  5. 用同步容器Collections.synchronizedList(new LinkedList<>())
  6. 只加volatile也能解决问题，但是具有偶然性，因为睡了一段时间正好错开了
  7. 更重要的是：volatile这里修饰的是一个列表的引用，照理说只能在引用改变时保持同步，而不能在引用所指向的对象发生发生改变时保持刷新
  8. ❓volatile修饰的引用指向的对象中的值发生了改变是观察不到的
  1. /**
  2.  * 曾经的面试题：（淘宝？）
  3.  * 实现一个容器，提供两个方法，add，size
  4.  * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
  5.  * 
  6.  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，
  7.  * 而且，如果在if 和 break之间被别的线程打断，得到的结果也不精确，
  8.  * 该怎么做呢？
  9.  * @author mashibing
  10.  */
  11. package com.mashibing.juc.c_020_01_Interview;
  13. import java.util.Collections;
  14. import java.util.LinkedList;
  15. import java.util.List;
  16. import java.util.concurrent.TimeUnit;
  19. public class T02_WithVolatile {
  21.     //添加volatile，使t2能够得到通知
  22.     // 加锁也是不行的，因为自己释放锁之后自己又会获得锁！
  23.     // 线程缓存的可见性与sleep的关系！！！
  24.     //volatile List lists = new LinkedList();
  25.     volatile List lists = Collections.synchronizedList(new LinkedList<>());
  27.     public void add(Object o) {
  28.         lists.add(o);
  29.     }
  31.     public int size() {
  32.         return lists.size();
  33.     }
  35.     public static void main(String[] args) {
  37.         T02_WithVolatile c = new T02_WithVolatile();
  38.         new Thread(() -> {
  39.             for(int i=0; i<10; i++) {
  40.                 c.add(new Object());
  41.                 System.out.println("add " + i);
  43.                 /*try {
  44.                     TimeUnit.SECONDS.sleep(1);
  45.                 } catch (InterruptedException e) {
  46.                     e.printStackTrace();
  47.                 }*/
  48.             }
  49.         }, "t1").start();
  51.         new Thread(() -> {
  52.             while(true) {
  53.                 if(c.size() == 5) {
  54.                     break;
  55.                 }
  56.             }
  57.             System.out.println("t2 结束");
  58.         }, "t2").start();
  59.     }
  60. }

wait、notify解决上述面试题

  1. notify是不释放锁的，假如用的是一把锁，是不行的
  2. 释放锁的方式：
    1. wait释放锁！
    2. synchronized代码块执行完毕释放锁！

下面这种方式仍然无法解决

  1. /**
  2.  * 曾经的面试题：（淘宝？）
  3.  * 实现一个容器，提供两个方法，add，size
  4.  * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
  5.  * 
  6.  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
  7.  * 
  8.  * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
  9.  * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
  10.  * 
  11.  * 阅读下面的程序，并分析输出结果
  12.  * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
  13.  * 想想这是为什么？
  14.  * @author mashibing
  15.  */
  16. package com.mashibing.juc.c_020_01_Interview;
  18. import java.util.ArrayList;
  19. import java.util.List;
  20. import java.util.concurrent.TimeUnit;
  23. public class T03_NotifyHoldingLock { //wait notify
  25.     //添加volatile，使t2能够得到通知
  26.     volatile List lists = new ArrayList();
  28.     public void add(Object o) {
  29.         lists.add(o);
  30.     }
  32.     public int size() {
  33.         return lists.size();
  34.     }
  36.     public static void main(String[] args) {
  37.         T03_NotifyHoldingLock c = new T03_NotifyHoldingLock();
  39.         final Object lock = new Object();
  41.         new Thread(() -> {
  42.             synchronized(lock) {
  43.                 System.out.println("t2启动");
  44.                 if(c.size() != 5) {
  45.                     try {
  46.                         lock.wait();
  47.                     } catch (InterruptedException e) {
  48.                         e.printStackTrace();
  49.                     }
  50.                 }
  51.                 System.out.println("t2 结束");
  52.             }
  54.         }, "t2").start();
  56.         try {
  57.             TimeUnit.SECONDS.sleep(1);
  58.         } catch (InterruptedException e1) {
  59.             e1.printStackTrace();
  60.         }
  62.         new Thread(() -> {
  63.             System.out.println("t1启动");
  64.             synchronized(lock) {
  65.                 for(int i=0; i<10; i++) {
  66.                     c.add(new Object());
  67.                     System.out.println("add " + i);
  69.                     if(c.size() == 5) {
  70.                         lock.notify();
  71.                     }
  73.                     try {
  74.                         TimeUnit.SECONDS.sleep(1);
  75.                     } catch (InterruptedException e) {
  76.                         e.printStackTrace();
  77.                     }
  78.                 }
  79.             }
  80.         }, "t1").start();
  83.     }
  84. }

正确解决方式

  1. notify的线程t1进行wait让出这把锁，才能让另一个线程继续
  2. t2中也要加个notify
  1. /**
  2.  * 曾经的面试题：（淘宝？）
  3.  * 实现一个容器，提供两个方法，add，size
  4.  * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
  5.  * 
  6.  * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
  7.  * 
  8.  * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
  9.  * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
  10.  * 
  11.  * 阅读下面的程序，并分析输出结果
  12.  * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
  13.  * 想想这是为什么？
  14.  * 
  15.  * notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
  16.  * 整个通信过程比较繁琐
  17.  * @author mashibing
  18.  */
  19. package com.mashibing.juc.c_020_01_Interview;
  21. import java.util.ArrayList;
  22. import java.util.List;
  23. import java.util.concurrent.TimeUnit;
  26. public class T04_NotifyFreeLock {
  28.     //添加volatile，使t2能够得到通知
  29.     volatile List lists = new ArrayList();
  31.     public void add(Object o) {
  32.         lists.add(o);
  33.     }
  35.     public int size() {
  36.         return lists.size();
  37.     }
  39.     public static void main(String[] args) {
  40.         T04_NotifyFreeLock c = new T04_NotifyFreeLock();
  42.         final Object lock = new Object();
  44.         new Thread(() -> {
  45.             synchronized(lock) {
  46.                 System.out.println("t2启动");
  47.                 if(c.size() != 5) {
  48.                     try {
  49.                         lock.wait();
  50.                     } catch (InterruptedException e) {
  51.                         e.printStackTrace();
  52.                     }
  53.                 }
  54.                 System.out.println("t2 结束");
  55.                 //通知t1继续执行
  56.                 lock.notify();
  57.             }
  59.         }, "t2").start();
  61.         try {
  62.             TimeUnit.SECONDS.sleep(1);
  63.         } catch (InterruptedException e1) {
  64.             e1.printStackTrace();
  65.         }
  67.         new Thread(() -> {
  68.             System.out.println("t1启动");
  69.             synchronized(lock) {
  70.                 for(int i=0; i<10; i++) {
  71.                     c.add(new Object());
  72.                     System.out.println("add " + i);
  74.                     if(c.size() == 5) {
  75.                         lock.notify();
  76.                         //释放锁，让t2得以执行
  77.                         try {
  78.                             lock.wait();
  79.                         } catch (InterruptedException e) {
  80.                             e.printStackTrace();
  81.                         }
  82.                     }
  84.                     try {
  85.                         TimeUnit.SECONDS.sleep(1);
  86.                     } catch (InterruptedException e) {
  87.                         e.printStackTrace();
  88.                     }
  89.                 }
  90.             }
  91.         }, "t1").start();
  94.     }
  95. }

总结

  1. volatile在没有把握时就不要用，除了面试的时候
  2. volatile尽量不要使用
  3. volatile最好修饰简单的，越简单越好，不要去修饰引用值
  4. wait和notify不一定所有情况下都需要成对出现—->根据自己的需求自己设置合适的同步策略即可！
  5. 好多线程阻塞用notifyAll，只有一个线程阻塞用notify
  6. notify是不释放锁的。notify唤醒其他线程之后，这里的其他线程还是需要拿到锁之后才能继续向下执行的。
  7. wait释放锁之后，还需要拿到锁才能继续往下执行
  8. 加锁后还出现问题的原因：释放锁后，因为自己执行的太快了，**自己又再次获得了锁！这让t2得不到恰当的判断时机**
  9. 这题的正确解法是用wait和notify来做，是一个线程之间的互斥同步问题，而不是去想直接用synchronized或者用volatile
  10. 考察的是线程的同步，而不是可见性问题（线程缓存sleep?）
  11. 考察的是线程之间的同步，即一个线程必须在另一个线程执行到什么步骤时输出，然后另一个线程才能继续执行
  12. sleep的作用是留时间给t2唤醒并输出（因为线程执行的太快了—->会造成即使能够正确可见，依旧会因为t1继续快速向下执行而造成t2输出的位置不对！！！）
  13. 尽量不要用volatile！！！
  14. 尽量不要用volatile！！！
  15. 尽量不要用volatile！！！