CAS-代码示例

一、CAS操作

为什么需要CAS操作？

/**
给定一个需求：统计一个网站的访问量，规定每次访问都让count+1
*/
package PracticeCAS;

import java.util.concurrent.CountDownLatch;

public class demo {
    static int count=0;

    public static void request() throws InterruptedException {

        Thread.sleep(5);
        /**
         * Q：每次获取到的count都不一样,这是为什么？如何解决
         * A：
         *      1.count++ 是有三步来完成的;(jvm执行引擎);
         *          获取count值->讲count值+1->将这个值返回给count
         *      2.多线程情况下， 如果有A/B两个线程，同时执行到 获取count值的这个步骤
         *          那么就会导致，count值只加了1，这样就导致了结果不正确;
         *      3.解决方式，在给count++的时候，做同步处理，同时只允许一个线程处理这个代码
         *      这样的话，就不会丢数据了
         *      4.在Java中 可以使用 synchronized或 ReentrantLock都可以是先对资源的加锁
         *      保证资源的安全性和正确性
         */
        count++;
    }

    public static void main(String[] args) throws InterruptedException {

        long startTime=System.currentTimeMillis();
        int size=100;
        CountDownLatch countDownLatch=new CountDownLatch(size);

        for (int i = 0; i < size; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }

                }
            }).start();
        }

        countDownLatch.await();
        long endTime=System.currentTimeMillis();

        System.out.println(endTime-startTime);
        System.out.println(count);
    }
}

常规解决数据不正确方式：

package PracticeCAS;

import java.util.concurrent.CountDownLatch;


public class demo02 {
    static int count=0;

    public synchronized static void request() throws InterruptedException {

        Thread.sleep(5);
        /**
         * Q：耗时太长的原因？
         * A：
         *      1.程序中的 synchronized 保证了这个方法同一时刻只有一个线程进入；
         *      这样虽然让count的值一定正确，但却延长了执行的时间
         *      那么如果解决的运行时间长的问题呢？
         *              解决方法就是把锁加到第三步，也就是 把加好的值返回给count的这一步加锁
         *
         *              原来版本的三步：
         *              1.获取count值
         *              2.讲count值+1
         *              3.将这个值返回给count
         *
         *              现在把第三步修改为：
         *                  1.获取锁
         *                  2.获取现在最新的值
         *                  3.判断最新的值，是否等于原来的值；如果相等，把结果返回给count
         *                  4.释放锁
         */
        count++;
    }

    public static void main(String[] args) throws InterruptedException {

        long startTime=System.currentTimeMillis();
        int size=100;
        CountDownLatch countDownLatch=new CountDownLatch(size);

        for (int i = 0; i < size; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }

                }
            }).start();
        }

        countDownLatch.await();
        long endTime=System.currentTimeMillis();

        System.out.println(endTime-startTime);
        System.out.println(count);
    }

}

模拟CAS操作实现：

package PracticeCAS;

import java.util.concurrent.CountDownLatch;

/**
 * 模拟CAS执行原理
 */
public class demo03 {
    volatile static int count = 0;

    public static void request() throws InterruptedException {

        Thread.sleep(5);
//        count++;
        int expectCount;
        while (!compareAndSwap(expectCount = getCount(), expectCount + 1)) ;

    }

    /**
     * @param expectCount 老值，或者也叫原来获取到的count值
     * @param newCount    新值，也就是需要赋值回去的值
     * @return
     */
    public static synchronized boolean compareAndSwap(int expectCount, int newCount) {
        if (getCount() == expectCount) {
            count = newCount;
            return true;
        } else {
            return false;
        }
    }

    public static int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {

        long startTime = System.currentTimeMillis();
        int size = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(size);

        for (int i = 0; i < size; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        countDownLatch.countDown();
                    }

                }
            }).start();
        }

        countDownLatch.await();
        long endTime = System.currentTimeMillis();

        System.out.println(endTime - startTime);
        System.out.println(count);
    }

}

二、Java中的CAS操作

CAS 全程ComparaAndSwap，中文翻译为：比较并替换

定义：

CAS操作包含三个操作数——内存位置(V)、期望值(A)和新值(B)

如果内存位置的值与期望值匹配，那么处理器就会自动将该位置值更新为新值，否则，处理器不做任何操作；无论那种情况，它都会在CAS指令之前返回该位置的值；

CAS在一些特殊情况下仅返回CAS是否成功，而不提取当前值，CAS有效的说明了

我人为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要改变该位置的值；只要告诉我这个位置现在的值即可；

Q：怎么使用JDK提供的CAS支持？

A：Java中提供了CAS操作的支持，具体在sun.misc.unsafe类中；具体声明如下：

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

/**
var1:表示要操作的对象
var2:表示要操作对象中属性地址的偏移量
var4:表示需要需要修改数据期望的值
var5:表示需要修改为的新值
*/

Q：CAS实现原理是什么？

A：

CAS通过JNI的代码来实现；JNI：Java native Interface，运行Java调用其他语言，而CompareAndSwapxxx系列的方法就是借助C语言来调用CPU底层指令实现的

以常用的intel x86平台来说，最终映射到CPU的指令为cmpxchg，这是一个原子指令

CPU执行此命令时，实现比较替换操作；

Q：现在的计算动不动上百核心，那么cmpxchg如何保证多核心下的线程安全？

A：系统底层进行CAS操作的时候，会判断当前系统是否为多核心系统；如果是多核心，就给从总线加锁，加所之后只有一个线程对总线加所成功，加锁成功之后，才会执行CAS操作，也就是说CAS的原子性时平台级别的！

Q：CAS这么牛逼，那么它还存在那些问题？

A：1.高并发场景下，对于一个操作有多个线程来执行CAS操作的时候，其他没有进入CAS操作的线程，依然会执行操作，当执行到最后一步的时候，直接开始了下一轮的计算；一直等到成功为止；

**2.ABA问题？**

Q：什么是ABA问题？

A：CAS需要在操作值的时候检查下值，有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，在CAS方法执行之前，被其他线程修改为B，然后又修改回了A，那么CAS方法执行检查的时候就会发现他的值没有修改，但是实际缺变化了，这就是CAS的ABA问题；

ABA问题详解： 其实可以理解为一个线程在执行CAS操作之前，他的CPU被别人抢走了，这个时候，其他线程修改A的值，把A修改为B，又把B修改为A，这个时候原来的线程才拿到CPU，这个时候进入CAS操作之后，这个线程发现需要操作的值没有修改，但实际上，A的值已经被修改两次了；

//代码演示 ABA问题
package PracticeCAS;

import java.util.concurrent.atomic.AtomicInteger;

public class CasABADemo {

    //原子变量 AtomicInteger
    public static AtomicInteger a = new AtomicInteger(1);

    public static void main(String[] args) {

        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  " + a.get());
                int expectInt = a.get();
                int newInt = expectInt + 1;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                boolean compareAndSet = a.compareAndSet(expectInt, newInt);
                System.out.println(compareAndSet);
                System.out.println(a.get());
            }
        });


        Thread ganrao = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                a.incrementAndGet();
                System.out.println(a.get());
                a.decrementAndGet();
                System.out.println(a.get());
            }
        });
        main.start();
        ganrao.start();
    }
}

Q：jdk如何解决ABA问题？

A：使用AtomicStampedReference；AtomicStampedReference主要包含一个对象引用以及一个可以自动更新的正数 stamp的Pair对象来解决ABA问题；

提示：使用AtomicStampedReference修改ABA BUG；

JDK解决思路：

通过添加版本来记录对应值的变化，只要版本号匹配不上，哪怕值是相同的也无法可以识别出来

模拟JDK解决ABA问题：

package PracticeCAS;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class DealABADemo {

    //原子变量 AtomicInteger
    public static AtomicStampedReference<Integer> a = new AtomicStampedReference<>(new Integer(1), 1);

    public static void main(String[] args) {

        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  " + a.getStamp());

                Integer expectR = a.getReference();
                Integer expectStamp = a.getStamp();

                Integer newP = expectR + 1;
                Integer newStamp = expectStamp + 1;


                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                boolean compareAndSet = a.compareAndSet(expectR, newP,expectStamp, newStamp);

                System.out.println(compareAndSet);
                System.out.println(a.getReference());
                System.out.println(a.getStamp());
            }
        });


        Thread ganrao = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


                a.compareAndSet(a.getReference(), a.getReference() + 1, a.getStamp(), a.getStamp() + 1);

                System.out.println(a.getReference());
                System.out.println(a.getStamp());

                a.compareAndSet(a.getReference(), a.getReference() - 1, a.getStamp(), a.getStamp() + 1);

                System.out.println(a.getReference());
                System.out.println(a.getStamp());
            }
        });

        main.start();
        ganrao.start();
    }

}