快了，快要拿到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);
}
}
文章参考：小刘老师讲源码
