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 {
//        模拟耗时5msTimeUnit.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() {@Overridepublic 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 {
//        模拟耗时5msTimeUnit.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() {@Overridepublic 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 {
//        模拟耗时5msTimeUnit.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赋值给countif (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() {@Overridepublic 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);}
}

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