14.线程系列- CAS，你需要知道的东西

最新推荐文章于 2024-05-16 07:19:47 发布

那个少年~

最新推荐文章于 2024-05-16 07:19:47 发布

阅读量123

点赞数

分类专栏： thread 文章标签：多线程

原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933166&idx=1&sn=15e614500676170b76a329efd3255c12&chksm=88621b10bf1592064befc5c9f0d78c56cda25c6d003e1711b85e5bfeb56c9fd30d892178db87&cur_album_id=1318984626890915841&scene=189#rd

版权

thread 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

本文主要内容

从网站计数器实现中一步步引出CAS操作
介绍java中CAS以及CAS可能存在的问题
悲观锁和乐观锁的一些介绍以及数据库乐观锁的一个常见示例
使用java中的原子操作实现网站计数器功能

我们需要解决的问题

方式1：

需求：我们开发了一个网站，需要对访问量进行统计，用户每次发一次请求，访问量+1，如何实现？

下面我们来模仿有100个人同时访问，并且每个人对网站发起10次请求，最后总访问次数应该是1000次。我们实现访问如下：

public class demo1 {

    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        long starTime = System.currentTimeMillis();
        int threadCount = 100;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(() -> {
                try {
                    for (int j = 0; j < 10; j++) {
                        request();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
            thread.start();
        }
        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime) + ",count=" + count);
    }

    //模拟访问一次
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        count++;
    }
}

输入结果:

main，耗时：95,count=950

多运行几次，count结果也不一样。

代码中采用的是多线程的方式来操作count，所以count++会有线程安全问题，count++操作实际上有以下三个步骤完成的：

获取count的值
count+1操作
再把count+1的值赋值给count

如果有A,B两个线程同时执行count++，可能当线程A执行到第一步之后，第三步之前时，线程B已经执行完步骤三，这时线程B设置count的值为1，但是A获取的count值还是0，当A继续执行后，把count设置为1，从而导致结果不准确

那么我们应该怎么做？

对count++操作的时候，我们让多个线程排队处理，多个线程同时到达request()方法的时候，只能允许一个线程可以进去操作，其他的线程在外面候着，等里面的处理完毕出来之后，外面等着的再进去一个，这样操作count++就是排队进行的，结果一定是正确的。

我们前面学了synchronized、ReentrantLock可以对资源加锁，保证并发的正确性，多线程情况下可以保证被锁的资源被串行访问，那么我们用synchronized来实现一下。

方式2：使用synchronized实现

 //模拟访问一次
    public static synchronized void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        count++;
    }

我们只修改request()方法。

main，耗时：5776,count=1000

程序中request方法使用synchronized关键字，保证了并发情况下，request方法同一时刻只允许一个线程访问，request加锁了相当于串行执行了，count的结果和我们预期的结果一致，只是耗时比较长，5秒多。

方式3

我们在看一下count++操作，count++操作实际上被拆分为3步骤执行：

1. 获取count的值，记做A：A=count
2. 将A的值+1，得到B：B = A+1
3. 让B赋值给count：count = B

方式2中我们通过加锁的方式让上面3步骤同时只能被一个线程操作，从而保证结果的正确性。

我们是否可以只在第3步加锁，减少加锁的范围？

对第3步做以下处理：

获取锁
第三步获取一下count的最新值，记做V
判断V是否等于A，如果相等，则将B的值赋值给count，并返回ture，否则返回false
释放锁

如果我们发现第3步返回的是false，我们就再次去获取count，将count赋值给A，对A+1赋值给B，然后再将A，B的值带入到上面的执行过程中，直到上面的结果返回ture为止

我们用代码来实现以下：

public class demo2 {

    volatile static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        long starTime = System.currentTimeMillis();
        int threadCount = 100;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(() -> {
                try {
                    for (int j = 0; j < 10; j++) {
                        request();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
            thread.start();
        }
        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime) + ",count=" + count);
    }

    //模拟访问一次
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        int v;
        do {
            v = getCount();
        } while (!compareAndSwap(v, v + 1));
    }

    static synchronized boolean compareAndSwap(int expectCount, int newCount) {
        if (getCount() == expectCount) {
            count = newCount;
            return true;
        }
        return false;
    }

    public static int getCount() {
        return count;
    }
}

运行结果：

main，耗时：151,count=1000

代码中用了volatile关键字修饰了count，可以保证count在多线程情况下的可见性。关于volatile关键字的使用，也是非常非常重要的，前面有讲过，不太了解的朋友可以去看一下

咱们再看一下代码，compareAndSwap方法，我们给起个简称吧叫CAS，这个方法有什么作用呢？这个方法使用synchronized修饰了，能保证此方法是线程安全的，多线程情况下此方法是串行执行的。方法由两个参数，expectCount：表示期望的值，newCount：表示要给count设置的新值。方法内部通过getCount()获取count当前的值，然后与期望的值expectCount比较，如果期望的值和count当前的值一致，则将新值newCount赋值给count。

再看一下request()方法，方法中有个do-while循环，循环内部获取count当前值赋值给了expectCount，循环结束的条件是compareAndSwap返回true，也就是说如果compareAndSwap如果不成功，循环再次获取count的最新值，然后+1，再次调用compareAndSwap方法，直到compareAndSwap返回成功为止。

代码中相当于将count++拆分开了，只对最后一步加锁了，减少了锁的范围，此代码的性能是不是比方式2快不少，还能保证结果的正确性。大家是不是感觉这个compareAndSwap方法挺好的，这东西确实很好，java中已经给我们提供了CAS的操作，功能非常强大，我们继续向下看。

CAS

CAS,compare and swap的缩写，中文翻译成比较并交换。

CAS操作包含3个操作数：V-内存位置，A-预期原值，B-新值。如果内存位置的值与预期原值相等，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。（在CAS的一些特殊情况下将仅返回CAS操作是否成功）

很多地方说CAS操作是非阻塞的，其实系统底层进行CAS操作的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，所以同一芯片上的其他处理器就暂时不能通过总线访问内存，保证了该指令在多处理器环境下的原子性。总线上锁的，其他线程执行CAS还是会被阻塞一下，只是时间可能会非常短暂，所以说CAS是非阻塞的并不正确，只能说阻塞的时间是非常短的。

JUC包中大部分功能都是依靠CAS操作完成的，所以这块也是非常重要的，有关Unsafe类，下篇文章会具体讲解。

synchronized、ReentrantLock这种独占锁属于悲观锁，它是在假设需要操作的代码一定会发生冲突的，执行代码的时候先对代码加锁，让其他线程在外面等候排队获取锁。悲观锁如果锁的时间比较长，会导致其他线程一直处于等待状态，像我们部署的web应用，一般部署在tomcat中，内部通过线程池来处理用户的请求，如果很多请求都处于等待获取锁的状态，可能会耗尽tomcat线程池，从而导致系统无法处理后面的请求，导致服务器处于不可用状态。

除此之外，还有乐观锁，乐观锁的含义就是假设系统没有发生并发冲突，先按无锁方式执行业务，到最后了检查执行业务期间是否有并发导致数据被修改了，如果有并发导致数据被修改了，就快速返回失败，这样的操作使系统并发性能更高一些。cas中就使用了这样的操作。

关于乐观锁这块，想必大家在数据库中也有用到过，给大家举个例子，可能以后会用到。

如果你们的网站中有调用支付宝充值接口的，支付宝那边充值成功了会回调商户系统，商户系统接收到请求之后怎么处理呢？假设用户通过支付宝在商户系统中充值100，支付宝那边会从用户账户中扣除100，商户系统接收到支付宝请求之后应该在商户系统中给用户账户增加100，并且把订单状态置为成功。由于网络等各种问题，可能支付宝回调商户系统的时候，回调超时了，支付宝又发起了一笔回调请求，刚好这2笔请求同时到达上面代码，最终结果是给用户账户增加了200，这样事情就搞大了，公司蒙受损失，严重点可能让公司就此倒闭了。

开启事务
获取订单信息
if(订单状态==待处理){
    给用户账户增加100
    将订单状态更新为成功
}
返回订单处理成功
提交事务

那我们可以用乐观锁来实现，给订单表加个版本号version，要求每次更新订单数据，将版本号+1，那么上面的过程可以改为：

获取订单信息,将version的值赋值给V_A
if(订单状态==待处理){
    开启事务
    给用户账户增加100
    update影响行数 = update 订单表 set version = version + 1 where id = 订单号 and version = V_A;
    if(update影响行数==1){
        提交事务
    }else{
        回滚事务
    }
}
返回订单处理成功

上面的update语句相当于我们说的CAS操作，执行这个update语句的时候，多线程情况下，数据库会对当前订单记录加锁，保证只有一条执行成功，执行成功的，影响行数为1，执行失败的影响行数为0，根据影响行数来决定提交还是回滚事务。上面操作还有一点是将事务范围缩小了，也提升了系统并发处理的性能。这个知识点希望你们能get到。

CAS的问题

CAS这么好用，那么有没有什么问题呢？

ABA问题

CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新。但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查的时候会发现他的值没有变化。但是实际上却变化了。这就是CAS的ABA问题。常见的解决思路是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A-B-A 就会变成1A-2B-3A。目前在JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

循环时间长开销大

上面我们说过如果CAS不成功，则会原地循环（自旋操作），如果长时间自旋会给CPU带来非常大的执行开销。并发量比较大的情况下，CAS成功概率可能比较低，可能会重试很多次才会成功。

使用JUC中的类实现计数器

juc框架中提供了一些原子操作，底层是通过Unsafe类中的cas操作实现的。通过原子操作可以保证数据在并发情况下的正确性

此处我们使用java.util.concurrent.atomic.AtomicInteger类来实现计数器功能。AtomicInteger内部采用CAS操作来保证对int类型数据增减操作。

示例：

public class Demo4 {
    //访问次数
    static AtomicInteger count = new AtomicInteger();

    //模拟访问一次
    public static void request() throws InterruptedException {
        //模拟耗时5毫秒
        TimeUnit.MILLISECONDS.sleep(5);
        //对count原子+1
        count.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        long starTime = System.currentTimeMillis();
        int threadSize = 100;
        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        for (int i = 0; i < threadSize; i++) {
            Thread thread = new Thread(() -> {
                try {
                    for (int j = 0; j < 10; j++) {
                        request();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
            thread.start();
        }

        countDownLatch.await();
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime) + ",count=" + count);
    }
}

输出：

main，耗时：119,count=1000

那个少年~

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
14.线程系列- CAS，你需要知道的东西

本文主要内容从网站计数器实现中一步步引出CAS操作介绍java中CAS以及CAS可能存在的问题悲观锁和乐观锁的一些介绍以及数据库乐观锁的一个常见示例使用java中的原子操作实现网站计数器功能我们需要解决的问题方式1：需求：我们开发了一个网站，需要对访问量进行统计，用户每次发一次请求，访问量+1，如何实现？下面我们来模仿有100个人同时访问，并且每个人对网站发起10次请求，最后总访问次数应该是1000次。我们实现访问如下：public class demo1 {
复制链接

扫一扫

专栏目录