1. import java.util.ArrayList;
    2. import java.util.List;
    4. /**
    5.  * volatile 关键字，使一个变量在多个线程间可见
    6.  * mian,t1线程都用到一个变量，java默认是T1线程中保留一份副本，这样如果main线程修改了该变量，
    7.  * t1线程未必知道
    8.  * <p>
    9.  * 使用volatile关键字，会让所有线程都会读到变量的修改值
    10.  * <p>
    11.  * 在下面的代码中，running是存在于堆内存的t对象中
    12.  * 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个副本，
    13.  * 并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
    14.  * <p>
    15.  * <p>
    16.  * 
    17.  * 
    18.  */
    19. @Slf4j(topic = "enjoy")
    20. public class Demo {
    22.     boolean running = true;
    23.     List<String> list = new ArrayList<>();
    25.     /**
    26.      * t1线程
    27.      */
    28.     public void test() {
    30.         boolean flag = running;
    31.         while (running) {
    32.             //加上任何一句话就会停止
    33.         }
    34.     }
    36.     public static void main(String[] args) {
    37.         Demo demo = new Demo();
    39.         new Thread(demo::test, "t1").start();
    41.         try {
    42.             Thread.sleep(100);
    43.         } catch (InterruptedException e) {
    44.             e.printStackTrace();
    45.         }
    47.         demo.running = false;
    48.     }
    50. }
    1. package com.shadow.demo10;
    3. import lombok.extern.slf4j.Slf4j;
    5. import java.util.ArrayList;
    6. import java.util.List;
    8. /**
    9.  * 比如说第一个线程加到100了，还没往上加，另外一个线程来了，把100拿过来执行方法，
    10.  * 然后第一个线程继续加到101，第二个线程也加到101，他两往回写都是101，线程不会管你加到哪儿了，
    11.  * 虽然说加了2但是实际上只加了1.
    12.  * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，
    13.  * 也就是说volatile不能替代synchronized或者说volatile保证不了原子性
    14.  */
    15. public class Demo {
    17.     volatile int count = 0;
    19.     public void test(){
    20.         for (int i = 0; i < 10000; i++) {
    21.             count ++;
    22.         }
    23.     }
    26.     public static void main(String[] args) {
    27.         Demo demo = new Demo();
    29.         List<Thread> threads = new ArrayList();
    31.         //new 10個线程
    32.         for (int i = 0; i < 10; i++) {
    33.             threads.add(new Thread(demo::test, "t-" + i));
    34.         }
    36.         //遍历这个10个线程  依次启动
    37.         threads.forEach((o)->o.start());
    39.         //等待10个线程执行完
    40.         threads.forEach((o)->{
    41.             try {
    42.                 o.join();
    43.             } catch (Exception e) {
    44.                 e.printStackTrace();
    45.             }
    46.         });
    48.          System.out.println(demo.count);
    49.     }
    51. }