Volatile

volatile作用

Volatile是Java虚拟机提供的轻量级同步机制
（1.保证可见性；2.不保证原子性；3.禁止指令重排）

可见性

线程需要从主内存中把数据读到自己的内存中，进行处理后再写回主内存，可见性就是现在一个线程修改了主内存中的值后，其它线程必须要知道这个值发生了改变，加了Volatile之后，变量值改变之后，所有的线程都可以知道。

实例代码

package tongbu;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author 
 * @create 2019/12/27 13:22
 */

class MyData{

    volatile int num = 0;

    public void addNum(){
        this.num = 60;
    }

    public void addNumPlus(){
        num++;
    }

    AtomicInteger atomicInteger = new AtomicInteger();

    public void addAtomicPlus(){
        atomicInteger.getAndIncrement();
    }

}

public class VolatileDemo {

    public static void main(String[] args) {
        MyData myData = new MyData();

        for (int i=1;i<=20;i++) {
            new Thread(() -> {
                for (int j=1;j<=1000;j++){
//                    myData.addNumPlus();
                    myData.addAtomicPlus();
                }
            },String.valueOf(i)).start();
        }

        while (Thread.activeCount()>2){
            Thread.yield();
        }

        System.out.println("over num"+ myData.num);
        System.out.println("over atomicInteger"+ myData.atomicInteger);

    }

    public static void volatileTest(){
        MyData myData = new MyData();
        new Thread(() -> {
            try {
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
            myData.addNum();
            System.out.println("num:"+myData.num);
        },"AAA").start();

        while (myData.num == 0){

        }

        System.out.println("over");
    }

}