1. volatile

1.1.什么是volatile

volatile是Java虚拟机提供的轻量级的同步机制，保证了可见性和有序性（禁止指令重排序），保证了JMM三个特性中的两个

1.2.JMM-Java内存模型

JMM的三个特性：
可见性、有序性、原子性
可见性：

线程在自己的工作内存中修改了从主内存中拷贝的共享变量副本后，并把修改后的值重新传到主内存中进行更新。这时我们要保证其他线程第一时间也可以得到共享变量已经被修改的通知。这样就保证了线程之间的一个可见性（因为线程间是不能直接访问对方的工作内存，所以可以从主内存下手）
有序性：
禁止指令重排，避免多线程的环境下，程序出现乱序执行的现象。
指令重排：计算机在执行程序时，为了提高性能，编译器和处理器常常回对指令做重排

原子性：
某个线程正在做某个具体业务时，中间不可以被加塞或者被分割。需要整体完整，要么同时成功，要么同时失败。

2 验证volatile的特性

2.1 可见性

package volatileTest;

class MyData{
    volatile int num=0;
    public void addTo60(){
        this.num=70;
    }
}
public class Test1 {
    public static void main(String[] args) {
        MyData data=new MyData();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "进来了。。。");
            try {
                Thread.sleep(3);//保证主线程已经得到了num=0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            data.addTo60();
            System.out.println(Thread.currentThread().getName()+"将值改为"+data.num);

        },"AAA").start();


        while (data.num==0){

        }
        System.out.println(Thread.currentThread().getName() + "近啦了");
            System.out.println(Thread.currentThread().getName()+"获取num="+data.num);
    }
}

说明：num被voalite修饰，AAA线程执行了addTo60后，将num的值改为70，如果没有可见性的话，主线程main是不会感受到num已经被修改了，应该会一直循环，但结果表明，main并没有一直在循环体中，而是可以得到70这个值，所以表明，volatile修饰了变量，使其具有可见性

2.2.验证volatile不保证原子性

package volitileTest;
/**
 * 验证volatile不保证原子性
 */
class Num{
    volatile int num=0;
    //20个线程对num进行加1操作，每个线程执行1000次，理论上应该为20000
    public void numAdd(){
        num++;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Num obj=new Num();
        for(int i=1;i<=20;i++) {
            new Thread(()->{
              for(int j=0;j<1000;j++){
                  obj.numAdd();
              }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"获取结果为："+obj.num);
    }
}

说明：理论值应该是20000，但实际结果小于20000.
为什么不能保证原子性，因为没有锁，线程会进行争抢，不能及时将修改后的值写回主内存

2.3 volatile实现禁止指令重排序

3.使用AtomicInteger解决volatile的不能实现原子性的问题

package volitileTest;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 验证volatile不保证原子性
 * 解决不保证原子性的问题--AtomicInteger
 */
class Num{
    volatile int num=0;
    //20个线程对num进行加1操作，理论上应该为20000
    public void numAdd(){
        num++;
    }

    AtomicInteger atomicInteger=new AtomicInteger();
    public void myAtomicAdd(){
        atomicInteger.getAndIncrement();//每次加1
    }
}
public class Test2 {
    public static void main(String[] args) {
        Num obj=new Num();
        for(int i=1;i<=20;i++) {
            new Thread(()->{
              for(int j=0;j<1000;j++){
                  obj.numAdd();
                  obj.myAtomicAdd();
              }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"获取结果为："+obj.num);
        System.out.println(Thread.currentThread().getName()+"获取结果为："+obj.atomicInteger);
    }
}

说明：可以看到使用了AtomicInteger后，得到的结果与预期相符

3.2 AtomicInteger的方法说明：

1.incermentAndGet()—相当于++i,先加1再返回

2.getAndIncrement()–相当于i++,先返回再加1

3.相同点，内部都调用了unsafe类的getAndAddInt（）方法

可以看到为什么AtomicInteger能实现原子性，因为原理是CAS

3.3 CAS

CAS=Compare and Set
CAS是指，在这个操作中，如果AtomicInteger的当前值是prev，那么就更新为一个预期值（这里预期值是当前值加1），返回true。如果AtomicInteger的当前值不是prev，就什么也不干，返回false。通过CAS操作并配合do … while循环，即使其他线程修改了AtomicInteger的值，最终的结果也是正确的。