volatile 代码解析

volatile 代码解析

1、volatile 关键字，使一个变量在多个线程间可见

A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
使用volatile关键字，会让所有线程都会读到变量的修改值

在下面的代码中，running是存在于堆内存的t对象中,当线程t1开始运行的时候，会把running值从内存中读到 t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行

使用 volatile 关键字将会强制所有线程都去堆内存中读取running的值

使用 volatile 可以实现无锁同步

public class T01_Volatile01 {
    //对比一下有无volatile的情况下，整个程序运行结果的区别
    /*volatile*/ boolean running = true;
    void m() {
        System.out.println("m start");
        while(running) {
//          try {
//              TimeUnit.MILLISECONDS.sleep(10);
//          } catch (InterruptedException e) {
//              e.printStackTrace();
//          }
        }
        System.out.println("m end!");
    }

    public static void main(String[] args) {
        T01_Volatile01 t = new T01_Volatile01();

        new Thread(t::m, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.running = false;


    }
}

2、volatile不能替代synchronized

volatile 并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized

public class T02_Volatile02 {

    volatile int count = 0;

    void m() {
        for (int i = 0; i < 10000; i++)
            count++;
    }

    public static void main(String[] args) {
        T02_Volatile02 t = new T02_Volatile02();

        List<Thread> threads = new ArrayList<Thread>();

        //创建 10个线程
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t::m, "thread-" + i));
        }

        //开启 10个线程去执行 m方法
        threads.forEach((o) -> o.start());

        //主线程等待开启的10个线程执行完后，才继续执行
        threads.forEach((o) -> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //发现cout的值使用小于 100000 （理论值）
        System.out.println(t.count);

    }
}

结论：synchronized可以保证可见性和原子性，volatile只能保证可见性