Java并发之CAS原理详解

更新时间:2023-04-06 04:20:22 阅读：评论：0

开端

在学习源码之前我们先从一个需求开始

需求

我们开发一个网站，需要对访问量进行统计，用户每发送一次请求，访问量+1.如何实现？我们模拟有100个人同时访问，并且每个人对咱们的网站发起10次请求，最后总访问次数应该是1000次

1.代码

package day03;import java.util.concurrent.countdownlatch;import java.util.concurrent.timeunit;/** * description * ur: * date: * time: */public class demo {    //总访问量    static int count = 0;    //模拟访问的方法    public static void request() throws interruptedexception {        //模拟耗时5毫秒        timeunit.milliconds.sleep(5);        count++;    }    public static void main(string[] args) throws interruptedexception {        long starttime = system.currenttimemillis();        int threadsize=100;        countdownlatch countdownlatch = new co戴维斯王朝untdownlatch(threadsize);        for (int i=0;i<threadsize;i++){            thread thread = new thread(new runnable() {                @override                public void run() {                    //每个用户访问10次网站                    try {                        for (int j=0;j<10;j++) {                            request();                        }                    }catch (interruptedexception e) {                        e.printstacktrace();                    }finally {                        countdownlatch.countdown();                    }                }            });            thread.start();        }        //怎么保证100个线程执行之后，执行后面的代码        countdownlatch.await();        long endtime = system.currenttimemillis();        system.out.println(thread.currentthread().getname()+"耗时:"+(endtime-starttime)+",count:"+count);    }}

我们多输出几次结果

main耗时:66,count:950

main耗时:67,count:928

发现每一次count都不相同，和我们期待的1000相差一点，这里就牵扯到了并发问题，我们的count++在底层实际上由3步操作组成

获取count，各个线程写入自己的工作内存count执行+1操作将+1后的值写回主存中

这并不是一个线程安全的过程，如果有a、b两个线程同时执行count++，同时执行到第一步，得到的count是一样的，三步操作完成后，count只加1，导致count结果不正确

那么怎么解决这个问题呢？

我们可以考虑使用synchronized关键字和reentrantlock对资源加锁，保证并发的正确性，多线程的情况下，可以保证被锁住的资源被串行访问

1.1修改后的代码

package day03;import java.util.concurrent.countdownlatch;import java.util.concurrent.timeunit;/** * description * ur: * date: * time: */public class demo02 {    //总访问量    static int count = 0;    //模拟访问的方法    public static synchronized void request() throws interruptedexception {        //模拟耗时5毫秒        timeunit.milliconds.sleep(5);        count++;    }    public static void main(string[] args) throws interruptedexception {        long starttime = system.currenttimemillis();        int threadsize=100;        countdownlatch countdownlatch = new countdownlatch(threadsize);        for (int i=0;i<threadsize;i++){            thread thread = new thread(new runnable() {                @override                public void run() {                    //每个用户访问10次网站                    try {                        for (int j=0;j<10;j++) {                            request();                        }                    }catch (interruptedexception e) {                        e.printstacktrace();                    }finally {                        countdownlatch.countdown();                    }                }            });            thread.start();        }        //怎么保证100个线程执行之后，执行后面的代码        countdownlatch.await();        long endtime = system.currenttimemillis();        system.out.println(thread.currentthread().getname()+"耗时:"+(endtime-starttime)+",count:"+count);    }}

执行结果

main耗时:5630,count:1000

可以看到，由于sychr闹伴娘事件onized锁住了整个方法，虽然结果正确，但因为线程执行方法均为串行执行，导致运行效率大大下降

那么我们如何才能使程序执行无误时，效率还不会降低呢？

缩小锁的范围，升级上述3步中第三步的实现

获取锁获取count最新的值，记作lv判断lv是否等于a，如果相等，则将b的值赋值给count，并返回true，否则返回fal释放锁

1.2代码改进：cas模仿

package day03;import java.util.concurrent.countdownlatch;import java.util.concurrent.timeunit;/** * description * ur: * date: * time: */public class demo03 {    //总访问量    volatile static int count = 0;    //模拟访问的方法    public static void request() throws interruptedexception {        //模拟耗时5毫秒        timeunit.milliconds.sleep(5);//        count++;        int expectcount;        while (!compareandswap(expectcount=getcount(),expectcount+1)){}    }    /**     * @param expectcount 期待的值,比如最刚开始count=3     * @param newcount 新值 count+1之后的值，4     * @return     */    public static synchronized  boolean compareandswap(int expectcount,int newcount){        if (getcount()==expectcount){            count = newcount;            return true;        }        return fal;    }    public static int getcount(){return count;}    public static void main(string[] args) throws interruptedexception {        long starttime = system.currenttimemillis();        int threadsize=100;        countdownlatch countdownlatch = new countdownlatch(threadsize);        for (int i=0;i<threadsize;i++){            thread thread = new thread(new runnable() {                @override                public void run() {                    //每个用户访问10次网站                    try {                        for (int j=0;j<10;j++) {                            request();                        }                    }catch (interruptedexception e) {                        e.printstacktrace();                    }finally {                        countdownlatch.countdown();                    }                }            });            thread.start();        }        //怎么保证100个线程执行之后，执行后面的代码        countdownlatch.await();        long endtime = system.currenttimemillis();        system.out.println(thread.currentthread().getname()+"耗时:"+(endtime-starttime)+",count:"+count);    }}

main耗时:67,count:1000

2.cas分析

cas全称“compareandswap”，中文翻译过来为“比较并替换”

定义：

cas操作包含三个操作数——内存位置（v）、期望值（a）和新值（b）。如果内存位置的值和期望值匹配，那么处理器会自动将该位置值更新为新值。否则处理器不作任何操作。无论哪种情况，它都会在cas指令之前返回该位置的值。cas在一些特殊情况下仅返回cas是否成功，而不提取当前值，cas有效的说明了我认为位置v应该包含值a，如果包含该值，将b放到这个位置，否则不要更改该位置的值，只告诉我这个位置现在的值即可

2.1java对cas的支持

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：表示需要修改的新值

2.2cas实现原理是什么？

cas通过调用jni的代码实现，jni：java native interface，允许java调用其他语言。而compareandswapxxx系列的方法就是借助c语言来调用cpu底层指令实现的

以常用的intel x86平台为例，最终映射到cpu的指令为”cmpxchg“，这是一个原子指令，cpu执行此命令时，实现比较并替换的操作

现代计算机动不动就上百核心，cmpxchg怎么保证多核心下的线程安全？

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

2.3cas存在的问题

2.3.1什么是aba问题？

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

可以看到上图中线程a在真正更改a之前，a已经被其他线程修改为b然后又修改为a了

程序模拟aba问题

package day04;import java.util.concurrent.atomic.atomicinteger;/** * description * ur: * date: * time: */public class test01 {    public static atomicinteger a = new atomicinteger();    public static void main(string[] args) {        thread main = new thread(new runnable() {            @override            public void run() {                system.out.println(thread.currentthread().getname()+"执行，a的值为:"+a.get());                try {                    int expect = a.get();                    int update = expect+1;                    //让出cpu                    thread.sleep(1000);                    boolean b = a.compareandt(expect, update);                    system.out.println(thread.currentthread().getname()+"cas执行:"+b+",a的值为:"+a.get());                }                 catch (interruptedexception e) {                    e.printstacktrace();                }            }   联泰商城     },"主线程");//        main.start();        thread thread1 = new thread(new runnable() {            @override            public void run() {                try {                    thread.sleep(20);                    a.incrementandget();                    system.out.println(thread.currentthread().getname()+"更改a的值为:"+a.get());                    a.decrementandget();                    system.out.println(thread.currentthread().getname()+"更改a的值为:"+a.get());                } catch (interruptedexception e) {                    e.printstacktrace();                }            }        },"其他线程");        main.start();        thread1.start();    }}

主线程执行，a的值为:0
其他线程更改a的值为:1
其他线程更改a的值为:0
主线程cas执行:true,a的值为:1

可以看到，在执行cas之前，a被其他线程修改为1又修改为0，但是对执行cas并没有影响，因为它根本没有察觉到其他线程对a的修改

2.3.2如何解春江花月夜翻译决aba问题

解决aba问题最简单的方案就是给值加一个修改版本号，每次值变化，都会修改它的版本号，cas操作时都去对比此版本号

在java中的aba解决方案（atomicstampedreference）

atomicstampedreference主要包含一个对象引用及一个可以自动更新的整数stamp的pair对象来解决aba问题

atomicstampedreference源码

    /**     * atomically ts the value of both the reference and stamp     * to the given update values if the     * current reference is {@code ==} to the expected reference     * and the current stamp is equal to the expected stamp.     *     * @param expectedreference the expected value of the reference 期待引用     * @param newreference the new value for the reference  金润吉秋意浓        新值引用     * @param expectedstamp the expected value of the stamp         期望引用的版本号     * @param newstamp the new value for the stamp                  新值的版本号     * @return {@code true} if successful     */    public boolean compareandt(v   expectedreference,                                 v   newreference,                                 int expectedstamp,                                 int newstamp) {        pair<v> current = pair;        return            expectedreference == current.reference &&//期望引用与当前引用保持一致            expectedstamp == current.stamp &&//期望引用版本号与当前版本号保持一致            ((newreference == current.reference &&//新值引用与当前引用一致并且新值版本号与当前版本号保持一致              newstamp == current.stamp)                    ||//如果上述版本号不一致，则通过caspair方法新建一个pair对象，更新值和版本号，进行再次比较             caspair(current, pair.of(newreference, newstamp)));    }    private boolean caspair(pair<v> cmp, pair<v> val) {        return unsafe.compareandswapobject(this, pairofft, cmp, val);    }

使用atomicstampedreference解决aba问题代码

package day04;import java.util.concurrent.atomic.atomicinteger;import java.util.concurrent.atomic.atomicreference;import java.util.concurrent.atomic.atomicstampedreference;/** * description * ur: * date: * time: */public class test02 {    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的值为:"+a.getreference());                try {                    integer expectreference = a.getreference();                    integer newreference = expectreference+1;                    integer expectstamp = a.getstamp();                    integer newstamp = expectstamp+1;                    //让出cpu                    thread.sleep(1000);                    boolean b = a.compareandt(expectreference, newreference,expectstamp,newstamp);                    system.out.println(thread.currentthread().getname()+"cas执行:"+b);                }                catch (interruptedexception e) {                    e.printstacktrace();                }            }        },"主线程");//        main.start();        thread thread1 = new thread(new runnable() {            @override            public void run() {                try {                    thread.sleep(20);                    a.compareandt(a.getreference(),a.getreference()+1,a.getstamp(),a.getstamp()+1);                    system.out.println(thread.currentthread().getname()+"更改a的值为:"+a.getreference());                    a.compareandt(a.getreference(),a.getreference()-1,a.getstamp(),a.getstamp()-1);                    system.out.println(thread.currentthread().getname()+"更改a的值为:"+a.getreference());                } catch (interruptedexception e) {                    e.printstacktrace();                }            }        },"其他线程");        main.start();        thread1.start();    }}