Java并发基石_CAS原理实战01_CAS机制入门

快了，快要拿到offer了！🌹

案例引入：
开发一个网站，对访问量进行统计，用户每发送一次请求，访问量就+1，模拟有100个人同时访问，并且每个人对网站发起10次请求，所以理论上访问量应该是1000。

代码实现：

package juc.cas;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Demo {
//        累计访问量
    static int count = 0;
    public static void request() throws InterruptedException {
//        模拟耗时5ms
        TimeUnit.MILLISECONDS.sleep(5);
//        count!=1000的原因就在于count++不是原子操作
        /**
         * 分为三步：
         * 获取count的值
         * 将count的值+1得到b
         * 将b赋值给count
         */
        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() {
                    try {
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception 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);

    }
}

关于CountDownLatch：
CountDownLatch是程序计数器，起到一个栅栏的作用，刚开始的时候为CountDownLatch设置一个值，即等待的线程数，CountDownLatch调用await（）方法时，需要判断等待的线程数是否为0，如果为0才能继续执行下面的代码。

执行结果：

问题出现的原因：
count++不是原子操作，实际上count++可以分为三个操作：

• 获取count的值，记作A，A=count
• 将A的值+1得到B的值，即B=A+1
• 最后再将B赋值给count

问题解决方案：
在对count做++操作的时刻，只允许一个线程可以操作，而其他线程在外排队等候，只有当当前线程操作结束，其他线程才能获得对count的操作权。在Java中，这种操作可以使用synchronized关键字来完成。

代码实现：

package juc.cas;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    //        累计访问量
    static int count = 0;
    public synchronized static void request() throws InterruptedException {
//        模拟耗时5ms
        TimeUnit.MILLISECONDS.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() {
                    try {
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception 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);

    }
}

加锁之后，可以保证count=1000了，但是显而易见的是，执行耗时增多了！

加synchronized之后，为什么程序变慢了？
显然，加了synchronized关键字之后，保证了并发的正确性，即在同一个时刻只允许一个线程操作count，只是耗时太长了（synchronized在方法上面，如果是静态方法，那么锁住的是class）。

如何解决耗时长的问题？
只在将B赋值给count的时候加锁，分为四步：

• 获取锁
• 获取count的最新值，记作V
• 判断V是否等于A，如果相等，则把B赋值给count，并返回true，否则返回false
• 释放锁

代码实现：

package juc.cas;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Demo3 {
    //        累计访问量
    volatile static int count = 0;
    public  static void request() throws InterruptedException {
//        模拟耗时5ms
        TimeUnit.MILLISECONDS.sleep(5);

        int expectCount;
        while (!compareAndSwap(expectCount=getCount(),expectCount+1)){

        }
    }

    /**
     *
     * @param expectCount 期望值
     * @param newCount 需要给count赋值的新值
     * @return 成功返回true，否则返回false
     */
    public static synchronized boolean compareAndSwap(int expectCount,int newCount){
//        判断count和expectCount是否相等，如果相等，则将expectCount赋值给count
        if (getCount()==expectCount){
            count = newCount;
            return true;
        }

        return false;
    }

    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() {
                    try {
                        for (int j = 0; j < 10; j++) {
                            request();
                        }
                    }catch (Exception 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);

    }
}

文章参考：小刘老师讲源码