乐观锁--CAS(Compare and swap)算法以及ABA问题

1.首先做一个测试：i++。输出结果为10，因为在底层实现的时候会引入一个临时变量具体为：

public static void main(String[] args) {
        //i++测试：
        int i=10;
        i=i++;
        System.out.println(i);
        /*
        *底层原理：
        _temp = i ;
        i = i + 1 ;
        i = _temp ;
        * */
    }

所以i++就是一个非原子性操作，采用多线程再次测试：测试结果中会因为i++的非原子性操作带来读写不一致问题。比如：1,3,2,2,4,5,6,7,8,9序列的出现。两个2的出现就说明了，两个线程在同时从主存中读取，和进行加一操作时出现的不一致问题，那么可以用Volatile来解决这个不一致问题吗？不行。因为，这是一个非原子性操作。

volatile变量具有 有序性(防止指令重排序)，可见性(对数据的写操作直接写到内存中)，不具有原子性。

public class TestAtomicDemo {
    public static void main(String[] args) {

        Testi testi = new Testi();

        for (int i = 0; i < 10; i++) {
            new Thread(testi, String.valueOf(i)).start();
        }
    }
}
class Testi implements Runnable{
    int a=1;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+": "+getA());
    }
    public int getA() {
        return a++;    
    }
}

2.Java并发包(java.util.concurrent)的主要实现机制：

采用Volatile保证内存的可见性；

采用CAS(Compare And Swap)算法保证数据的原子性。

3.乐观锁(CAS算法)和悲观锁(synchronized)：

Synchronized就是一种悲观锁，因为它总是假设最坏的情况，每次去拿数据都会认为别人会修该，所以每次都会加锁，效率较低。

乐观锁其实是一种思想，它具体有两个步骤：冲突检测和数据更新。所以它不会每次访问都进行加锁控制，只是在进行更新操作时才进行冲突检测和数据更新，适合用于读操作较多的程序，因此大大提高了吞吐量。其实现方式比较典型的就是CAS算法。当多个线程同时更新同一个变量时，只会有一个线程成功修改，其他的都会失败，更新失败的线程不会被挂起，而是被告知在这次竞争中失败了，并可以再次尝试。

4.CAS(Compare And Swap)原理: 

首先涉及三个操作数：

内存值（V）--->首次读取内存中的值；

预估值（A）--->再一次读取的内存中的值；

更新值（B）--->新值；

每次在进行更新操作时，当且仅当V==A(内存值和预期值相等时)，后 V=B（将内存值更新为B），否则不进行任何操作。

CAS是一种非阻塞算法的常见实现，JUC性能因此大大提升。

//模拟CAS算法：
public class TestCAS {
    public static void main(String[] args) {
        Cas cas = new Cas(10);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                //10个线程都进行对数据的更新操作
                int expectedValue = cas.getValue();  //更新前获得预期值
                boolean b = cas.CompareTest(expectedValue, (int) Math.random());
                System.out.println(b);

            }).start();
        }
    }
}
class Cas{
    /*
    * 内存值；预期值；新值。
    * */

    int value;  //内存值

    public synchronized int getValue() {
        return value;
    }

    public Cas(int value) {   //构造方法
        this.value = value;
    }

    //比较交换，并将内存值返回
    public int CompareSwap(int expectedValue,int newValue){
        int oldValue=value;  //获得内存值
        if(oldValue==expectedValue){
            value=newValue;
        }
        return oldValue;
    }

    //检测是否更新成功
    public boolean CompareTest(int expectedValue,int newValue){
        boolean flag=false;
        if(expectedValue==CompareSwap(expectedValue,newValue)){
            //判断预期值和内存值是否相等->更新是否成功
            flag=true;
        }
        return flag;
    }
}

CAS算法的ABA问题（当前线程的CAS操作无法分辨，值是否已经发生过变化）：解决方法->在修改值的同时增加一个时间戳，只有当预期值和时间戳都相同时才进行修改。