理解volatile与synchronized

用 volatile 修饰的变量可以保证线程的“可见性”，也就是，任何线程修改了这个 volatile 修饰的值都会通知其他线程来主缓存中重新读取值。

下面通过例子加以说明：

public class VolatileTest {
    // 对比有无 volatile 关键字的区别
    volatile boolean running = true;

    public void m(){
        System.out.println("start run");
        while (running){
        }
        System.out.println("end run");
    }

    public static void main(String[] args) {
        VolatileTest volatileTest = new VolatileTest();
        new Thread(volatileTest::m, "t1").start();
        try {
            //主线程睡眠一秒钟，目的是保证t1获得cpu执行权
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        volatileTest.running = false;
    }
}

有volatile的情况下，程序会输出:
start run
end run
无volatile的情况下，程序会输出:
start run

出现这种情况的原因跟java的内存模型（JMM）有关，每个线程运行都有自己独立的一份内存，用于保存线程的局部变量，线程修改一个全局变量要经过三个过程：

i. 拷贝主内存的变量到线程内存。

ii. 修改拷贝的变量值。

iii. 把修改的值写回主内存。

由于线程修改一个公共变量需要这三个步骤，可见这个修改不具备“原子性”，这也就是volatile和synchronized的不同之处，volatile不能取代synchronized来使用。

如下面例子所示：

public class VolatleAndSynchornized {
    public volatile int count = 0;
    
//    public synchronized void incre(){
     public void incre(){
        for (int i = 0; i < 10000; i ++){
            count ++;
        }
    }
    
    public static void main(String[] args) {
        VolatleAndSynchornized obj = new VolatleAndSynchornized();
        obj.process();
        System.out.println(obj.count);
    }
    
    public void process() {
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 5; i ++) {
            try {
                Runner t = new Runner();
                threads.add(t);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        threads.forEach(Thread::start);
    
        threads.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
    
    public class Runner extends Thread {
        @Override
        public void run() {
            incre();
        }
    }
}

用volatile的话输出：(每次运行结果不见得相同)
24236
而用synchronized的话输出：
50000