volatile的理解

一。volatile是java虚拟机提供的轻量级的同步机制

　　　   1.保证可见性

  1.1 假如 int number = 0;number变量之前没有添加volatile，没有可见性，不会走到第三步
  1.2 number变量之前添加volatile，具有可见性，3秒之后会走到第三步

class MyData {
    volatile int number = 0;

    public void addTo60() {
        this.number = 60;
    }
}

public class VolatileDemo {
    public static void main(String[] args){
        seeOkByVolatile();
    }
    public static void seeOkByVolatile() {
        MyData myData = new MyData();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+" start");// 第一步
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName()+" update end value: "+myData.number);// 第二步
        }, "AAA").start();

        while (myData.number == 0) {

        }
        System.out.println(Thread.currentThread().getName()+" value:"+myData.number);// 第三步
    }


}

　　　　2.不保证原子性

　　结果：输出小于20000

　　原因：number++这个操作实际上可以分为3个步骤

　　　　1.从主内存中读取number=0的值，复制到工作内存中

　　　　2.在工作内存中进行加1操作

　　　　3.将加1后的值赋给主内存

　　分析：有两个线程T1，T2同时进行number++操作时，当T1进行完1,2,3步骤后 number=1，T2刚执行完1,2还没有执行完3(number = 0 + 1)number=1

　　　　　有重新赋值给主内存，导致两个线程都对number加1，最终只增加了1次。

　　方案：怎么保证原子性

　　　　1.使用 synchronized

class MyData {
    volatile int number = 0;
    public void addPluxPlux() {
        number++;
    }
}
public class VolatileDemo {
    public static void main(String[] args){
        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    myData.addPluxPlux();
                }
            },String.valueOf(i)).start();
        }
        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println("number: "+myData.number); 
    }
}

　　　　 2.使用原子类AtomicInteger

　　　　输出结果：number<20000,atomic=20000

class MyData {
    volatile int number = 0;
    public void addTo60() {
        this.number = 60;
    }
    public void addPluxPlux() {
        number++;
    }

    AtomicInteger atomic = new AtomicInteger();
    public void atomicAddPlux(){
        atomic.incrementAndGet();
    }
}

public class VolatileDemo {
    public static void main(String[] args){
        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    myData.addPluxPlux();
                    myData.atomicAddPlux();
                }
            },String.valueOf(i)).start();
        }

        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println("number: "+myData.number);
        System.out.println("atomic: "+myData.atomic);

    }
}

　　　　3.禁止指令重排

　　指令重排必须要考虑指令之间的数据依赖性