java記憶體模型中的volatile關鍵字保證：

1. 保證多執行緒共享變數的可見性，但是不能保證原子性
2. synchronized 關鍵字保證了操作的原子性，可見性，但是不能保證指令重拍
3. volatile關鍵字保證了指令的重排序，java記憶體模型要求對volatile變數的寫操作先與volatile變數的讀操作

看程式碼

package com.bootdo.testDemo.rpc;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

class MyList{

    private  volatile List<Integer> list=new ArrayList<>();

    public void add(int data){
        list.add(data);
    }

    public int getSize(){
        return list.size();
    }
}
class ThreadB extends Thread{

    private MyList myList;

    public ThreadB(MyList myList){
        super();
        this.myList=myList;
    }

    @Override
    public void run() {
        try{
            while(true){
                if(myList.getSize()==2){
                    System.out.println("threadB interrupt");
                    throw new InterruptedException();
                }

                //System.out.println("threadB size="+myList.getSize());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }

    }
}
class ThreadA extends Thread{
    private MyList myList;

    public ThreadA(MyList myList){
        super();
        this.myList=myList;
    }
    @Override
    public void run() {

        for(int i=0;i<3;i++){
            myList.add(3);
            System.out.println("threadA add :size="+myList.getSize());

            try {
                //注意這裡休眠是為了保證讓出cpu執行時間，保證執行緒ThreadB執行，讓兩個執行緒交替執行
                Thread.sleep(1000);   
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class ThreadDemo {
    static volatile MyList myList=new MyList();

    public static void  show(){
        Thread threada=new ThreadA(myList);
        Thread threadb=new ThreadB(myList);
        threada.setName("threada");
        threadb.setName("threadb");
        threada.start();
        threadb.start();
    }

    public static void main(String[] args) {
        ThreadDemo2 threadDemo2=new ThreadDemo2();
        new Thread(threadDemo2,"threadDemo2").start();

        while(true){

            System.out.println(" hahaha......");     //1  可以導致執行緒中斷

            /**
             * public void println(String x) {
             * synchronized (this) {
                    print(x);
                    newLine();
                }
                }
             */

            synchronized (ThreadDemo.class){}       //2 可以導致執行緒中斷

            ThreadDemo.test2();                    //3可以導致執行緒中斷   synchronized 保持執行緒的可見性
            ThreadDemo.test1();                    //4 main 執行緒陷入死迴圈

            if(threadDemo2.flag){
                System.out.println("main thread exit :");
                break;
            }
        }
    }

    public static void test1(){}

    public static  synchronized void test2(){}


    static class  ThreadDemo2 extends Thread{

        private  boolean flag=false;

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag=true;

            System.out.println(Thread.currentThread().getName()+" 執行緒結束:flag="+flag);
        }
    }
}