初始JavaEE篇——多线程（7）：定时器、CAS

找往期文章包括但不限于本期文章中不懂的知识点：

个人主页：我要学编程程(ಥ_ಥ)-CSDN博客

所属专栏：JavaEE

定时器的使用

定时器的原理

模拟实现定时器

CAS

介绍

CAS的应用场景

解析 AtomicInteger 类

实现自旋锁

CAS的缺陷：ABA问题

现在我们来学习最后一个多线程的经典案例：定时器。这个与我们日常生活中的闹钟一样，到了一定的时间就开始响个不停，只不过，定时器这里不是响，而是去执行某个任务。

定时器的使用

我们可以来使用一下Java标准库中对应的定时器，对应的类是 Timer。

上面的创建定时器的四个构造方法。

定时器中执行任务的方法是：schedule（这个是把任务添加到队列中，最终的执行还是 run来）。

TimerTask 是指我们要处理的任务，Date 是指从什么时候开始执行，当前系统的时间+我们设置的时间就是最终的要开始执行任务的时间。

现在我们就可以来演示：

public class Test {public static void main(String[] args) {Timer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("timer执行的第一个任务");}}, 1000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("timer执行的第二个任务");}}, 2000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("timer执行的第二个任务");}}, 3000);System.out.println("Hello main");}
}

运行结果：

定时器的原理

定时器就是底层有一个线程，用来接收任务，然后在指定的时间来执行这些任务，如果一个定时器有多个任务，这些任务会根据执行时间的先后关系来存放到一个优先级队列中，时间一到就会执行优先级最高的任务。

模拟实现定时器

要求：实现和Java标准库中一样的效果。

思路：我们已经知道了定时器是通过线程+优先级队列来完成计时完成任务的。线程是用来不断的执行任务的，而优先级队列是用来拿到最先要执行的任务的。那么优先级队列中存储的就是我们要执行的任务以及对应的时间，那么我们可以创建一个任务类，既包含要执行的任务，也包含任务什么时候可以执行，这两个参数。当然，我们也要去实现比较的策略（自定义的类就得去实现），schedule 方法是将任务添加到队列中，让线程去队列中拿任务并执行。

代码实现：

任务类：任务+时间组成：

class MyTimerTask implements Comparable<MyTimerTask> {private Runnable task = null;private long time = 0;// 要执行的任务和多久执行public MyTimerTask(Runnable task, long time) {this.task = task;this.time = time;}@Overridepublic int compareTo(MyTimerTask o) {return (int) (this.time - o.time);}public long getTime() {return time;}public void run() {task.run();}
}

定时器类：构造方法+schedule方法：

public class MyTimer {private final PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();public MyTimer() {Thread t = new Thread(()->{while (true) { // 确保线程不会被销毁synchronized (this) {// 判断队列是否为空while (queue.isEmpty()) {try {this.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}// 拿到任务MyTimerTask task = queue.peek();// 看看是否到了执行的时机了if (System.currentTimeMillis() < task.getTime()) {try {this.wait(task.getTime() - System.currentTimeMillis());} catch (InterruptedException e) {throw new RuntimeException(e);}} else {// 执行任务并将堆首元素给踢出去task.run();queue.poll();}}}});t.start();}public void schedule(Runnable task, long time) {// 把任务添加到队列中synchronized (this) {// 1、创建任务(任务是什么+任务的执行时刻)MyTimerTask myTimerTask = new MyTimerTask(task, time+System.currentTimeMillis());// 2、把任务添加到队列中queue.offer(myTimerTask);// 3、唤醒空队列的阻塞this.notify();}}
}

测试代码：

public class Test {public static void main(String[] args) {MyTimer myTimer = new MyTimer();myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("Hello 3000");}}, 3000);myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("Hello 2000");}}, 2000);myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("Hello 1000");}}, 1000);System.out.println("main线程结束");}
}

运行结果：

CAS

介绍

CAS是一个CPU的指令，全称是 Compare And Swap，比较和交换。这个CAS是一条指令，也就是比较和交换的操作是原子的。

下面是CAS的伪代码：

// 假设我们有一个共享变量 value，和一个用于操作的函数 CAS
// CAS函数接受三个参数：内存地址（实际上是指向共享变量的指针）、预期值、要交换的值boolean CAS(address, expectedValue, swapValue) {// 获取内存地址中的当前值currentValue = *address// 检查当前值是否与预期值相等if (currentValue == expectedValue) {// 如果相等，将内存地址中的值更新为要交换的值*address = swapValuereturn true} else {// 如果不相等，返回 false，表示交换操作失败return false}        
}

CAS的应用场景

既然CAS本身是原子的，那么我们就可以利用这种性质来实现原子类，从而让线程不安全的代码变为线程安全。

Java标准库中提供了 java.util.concurrent.atomic 包，这个包中全部是利用CAS来实现的原子类。

代码演示：

public class Test {private static int count1 = 0;// 原子类是一个类，注意创建语法private static AtomicInteger count2 = new AtomicInteger();public static void main(String[] args) {// 1、使用普通类、普通的线程的去计算countAdd1();System.out.println("count1："+count1);// 2、使用原子类、普通的线程去计算countAdd2();System.out.println("count2："+count2);}private static void countAdd2() {Thread t1 = new Thread(()->{for (int i = 0; i < 100000; i++) {count2.getAndAdd(1); // 类似于后置++}});Thread t2 = new Thread(()->{for (int i = 0; i < 100000; i++) {count2.getAndAdd(1); // 类似于后置++}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {throw new RuntimeException(e);}}private static void countAdd1() {Thread t1 = new Thread(()->{for (int i = 0; i < 100000; i++) {count1++;}});Thread t2 = new Thread(()->{for (int i = 0; i < 100000; i++) {count1++;}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

运行结果：

从结果我们也可以看出，原子类是本身就是线程安全的，因此就不需要进行加锁操作。

解析 AtomicInteger 类

当然，上面的方法是先得到旧值，再去进行add操作，即最终得到的是add操作之前的旧值；而 addAndGet 方法是先进行add操作，再返回add操作之后的值，即最终得到的是add操作之后的新值。

原子类之所以会可以保障线程安全，是因为原子类会在进行"写"操作之前，再检查一下寄存器中的值是否与内存中的值是否一致，如果不一致的话，就会去修改寄存器中的值。这样就保障了寄存器中的值与内存中的值在"写"操作之前，一定是一致的，而这个确保机制就是CAS来实现的。

实现自旋锁

CAS也是可以实现自旋锁的。自旋锁是一种乐观锁的策略。与悲观锁相比，其会一直去等待别的线程释放这个锁，并且第一时间拿到这个锁。

private Object locker = null; // 锁while (!CAS(locker,null,Thread.currentThread())) {}public class SpinLock {private Object locker = null; // 自旋锁// 加锁public void lock() {// 判断当前锁是否被其他线程持有。// 如果被其他线程持有，就会返回false，从而一直循环判断// 如果没有被其他线程持有，就会将锁改为当前线程持有，并返回true，退出循环while (!CAS(locker,null,Thread.currentThread())) {}}// 解锁    private void unlock() {locker = null;}
}

CAS的缺陷：ABA问题

任何东西都不可能是完美的，CAS也是一样。CAS虽然会在每次进行"写"操作之前，进行判断内存中的值和寄存器中的值是否一致，但是当中间有个线程突然插一脚将内存的值改为了其他的值，后面又给改回来了呢？这就会导致这次在"写"操作时，可能会带来不可忽略的严重错误。

举个例子（经典案例）：

假设小琳银行卡有 100 块钱余额，且假定银行转账操作就是一个单纯的 CAS 命令，对比余额旧值是否与当前值相同，如果相同则发生扣减/增加，我们将这个指令用 CAS(origin,expect) 表示。于是，我们看看接下来发生了什么：小琳在 ATM 1 转账 100 块钱给小李；由于ATM 1 出现了网络拥塞的原因卡住了，这时候小琳跑到旁边的 ATM 2 再次操作转账； ATM 2 没让小琳失望，执行了 CAS(100,0)，很痛快地完成了转账，此时小琳的账户余额为 0；小王这时候又给小琳账上转了 100，此时小琳账上余额为 100；这时候 ATM 1 网络恢复，继续执行 CAS(100,0)，居然执行成功了，小琳账户上余额又变为了 0；这时候小王微信跟小琳说转了 100 过去，是否收到呢？小琳去查了下账，摇了摇头，并未收到账。

分析：

1、最初小琳银行卡余额为 100，我们将这个状态记为 A（余额 100）。

2、当 ATM 2 成功转账后，余额变为 0，这是状态 B（余额 0）。

3、然后小王转账 100，余额又变回 100，这就回到了状态 A（余额 100）。

4、最后 ATM 1 恢复之后，重新检查了小琳的余额，发现与之前的余额是一样的，因此成功执行转账，又将余额变为 0。

整个过程中，余额从 100（A）变成 0（B），然后又变回 100（A），而 CAS 操作只检查余额是否为最初的 100，没有察觉到中间的变化，导致了不符合预期的转账操作。

形成ABA问题的关键：