Volatile不保证原子性(未完

首先，JMM（Java内存模型）要求保证原子性，volatile是轻量级的同步机制，为什么是轻量级呢？（因为它不保证原子性，说白了，就是低配版/乞丐版的synchronized。

一、原子性是什么东东？

（跟MySQL上那个事务性的原子差不多（言下之意就是不可分割，完整性，也即某个线程正在做某个具体业务，中间不可以被加塞或者被分割。需要整体完整，要么同时成功，要么同时失败。）

这个时间段，应只允许一个人来操作（我的操作不要被你的操作覆盖了

原子性保证数据的一致性

二、volatile不保证原子性的案例演示

//我在做的时候别人不要来打岔，不要把我的操作砍成两段

class MyData
{
    volatile int number = 0;

    public void addTo60(){
        this.number = 60;
    }
    public void addPlusPlus(){
        number++;
    }
}
public class VolatileDemo {
    public static void main(String[] args) {
        //用二十个线程来动MyData中的number
        //每个线程操作addPlusPlus一千次
        //一共2万

        MyData myData=new MyData();

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

        //需要等待上面20个线程全部都计算完成后，再用main线程取得最终的结果值看是多少
        while (Thread.activeCount()>2){ //后台本来至少有两个线程，一个是main，一个是GC
            Thread.yield();//运行到这里时main线程拿到cpu再执行，没有阻塞，只是状态由运行中->就绪状态
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value: "+myData.number);
    }
}

应该是某个线程还没有写回去的时候就有其他线程进来拿了number

加了synchronized之后

但这种方法是杀鸡用牛刀，synchronized太重了，为了一个number++，没必要

三、理论解释：多个线程去操作主物理内存里的变量，（先副本拷贝，然后本地改完了要写回去，就会发生线程写丢失，写覆盖的问题。

四、解决办法：使用 AtomicInteger

class MyData
{
    volatile int number = 0;

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

    AtomicInteger atomicInteger = new AtomicInteger();
    public void addMyAtomic(){
        atomicInteger.getAndIncrement();
    }

}
public class VolatileDemo {
    public static void main(String[] args) {
        //用二十个线程来动MyData中的number
        //每个线程操作addPlusPlus一千次
        //一共2万

        MyData myData=new MyData();

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myData.addPlusPlus();
                    myData.addMyAtomic();
                }
            },String.valueOf(i)).start();
        }
    
        while (Thread.activeCount()>2){ //后台本来至少有两个线程，一个是main，一个是GC
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value: "+myData.number);
        System.out.println(Thread.currentThread().getName()+"\t finally number value: "+myData.atomicInteger);
    }
}

输出：

main     finally number value: 18969
main     finally number value: 20000

结论：

在多线程环境下，别用number++；不安全

用原子类AtomicInteger

五、为什么AtomicInteger的操作可以不加synchronized就能保证原子性呢？（AtomicInteger原理）

 

 

/**
 *Atomically increments by one the current value.
 *
 * this:当前对象
 *valueoffset:内存偏移量\内存地址
 */
public final int getAndIncrement(){
    return unsafe.getAndAddInt(this, valueoffset ,1);
}

 /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

 

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

看源码可知，AtomicInteger也有用volatile修饰，

Unsafe是CAS的核心类，Java中CAS操作的执行依赖于Unsafe类的方法（看上面源码）就是靠Unsafe来保证原子性。原本Java是要通过本地（native）方法来访问底层系统的，Unsafe、就像一个后门，基于这个类可以直接操作特定内存的数据

Unsafe类中的所有方法都是natice修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

总结：原子整型（AtomicInteger)之所以在多线程number++这种操作中不加synchronized也能保证线程安全，是因为他

①用了Unsafe类。

② AtomicInteger类里的变量valueOffset（看上面源码，调用unsafe的objectFieldOffset由此方法赋值）表示value变量值在内存中的偏移量地址，getAndIncrement(){ return unsafe.getAndAddInt(this, valueOffset, 1),拿到地址，确定到变量在内存中的位置，然后进行加1操作。

（是不是说，直接操作内存，而没有拷贝副本到自己线程工作空间，所以不用担心出现线程安全问题？）

③变量value用volatile修饰，保证了多线程之间的内存可见性。

总结：①volatile虽然保证可见（保证使用同一主物理内存变量的线程一直拿到新的值，而不是拿着旧的值得出错误的结果），但会被打断

          ②CAS是原语，不会被打断，且用volatile保证可见性

          ③AtomicInteger的方法是调用unsafe的方法的，unsafe是底层运用CAS，所以AtomicInterger既保证可见性，也保证原子性