volatile在可见性和有序性的基础上,如何保证原子性

volatile

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。

注意

volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）

CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果

AtomicInteger

在JDK1.5之后提供了一个在util包下的comcurrent包下的atomic包(原子包)
    里面提供对各种类的原子操作

AtomicInteger常用方法?
    构造方法:
        public AtomicInteger();
        public AtomicInteger(int initialValue);

    成员方法:
        int get(); 获取值
        int getAndIncrement(); 以原子方式将当前值+1, 返回自增前的值
        int incrementAndGet(); 以原子方式将当前值+1, 返回自增后的值
        int addAndGet(int data); 以原子方式将当前值和参数相加, 返回相加结果
        int getAndSet(int value); 以原子方式设置为参数的值, 返回旧值

CAS实现原理

AtomicInteger原理: CAS + 自旋
    有三个操作数据 (内存值V, 旧值A, 要修改的值B)
    当旧值A == 内存值, 证明在当前线程操作时, 没有其他线程来过, 此时可以修改, 将V改为B
    当旧值A != 内存值, 证明在当前线程操作时, 有其他线程来过, 此时不能修改, 进行自旋
       自旋: 重新获取现在的最新内存值V, 继续进行上述判断

简单理解:
    在修改共享数据时, 将修改前的旧值记录下来
        如果现在的内存值, 和原来的旧值一样, 证明没有其他县城操作过内存值, 则可以修改内存值
        如果现在的内存值, 和原来的旧值不一样, 证明有其他线程操作过内存值, 则不能修改内存值
            继续获取最新的内存值, 再次进行上述操作(自旋)

CAS算法图解:

CAS （也有 Compare And Swap 的说法）

注意

其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。

• 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。

为什么无锁效率高

• 无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。打个比喻

• 线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速... 恢复到高速运行，代价比较大

• 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。

 

CAS 的特点

结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

• CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。

• synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。

• CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思

  • 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一

  • 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响(线程上下文切换)

synchronized和CAS的区别:

    1.相同点: 
        在多线程的情况下, 都可以保证共享数据的安全性
        
    2.不同点
        synchronized是从最坏的角度出发, 认为每次获取数据的时候, 别人都有可能修改, 所以每次操作共享数据之前, 都会上锁 (悲观锁)
            
        CAS时候从乐观的角度出发, 认为每次获取数据的时候, 别人都不会修改, 所以不会上锁. 只不过在修改共享数据的时候, 检查一下别人有没有操作过这个数据 (乐观锁)
        如果操作了, 那么再次获取最新的值
        如果没有操作, 那么直接修改共享数据的值

总结:解决volatile原子性的办法

            1. 同步锁(效率低)
            2. AtomicInteger(效率高,线程安全)