初始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() {
            @Override
            public void run() {
                System.out.println("timer执行的第一个任务");
            }
        }, 1000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer执行的第二个任务");
            }
        }, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public 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;
    }

    @Override
    public 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() {
            @Override
            public void run() {
                System.out.println("Hello 3000");
            }
        }, 3000);

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello 2000");
            }
        }, 2000);

        myTimer.schedule(new Runnable() {
            @Override
            public 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 = swapValue
        return 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问题的关键：

1、某个线程需要重复读取某个内存地址，并以内存地址的值变化作为该值是否变化的唯一判定依据；

2、重复读取的变量会被多线程共享，且存在『值回退』的可能，即值变化后有可能因为某个操作重新变为原值；

3、在多次读取间隔中，没有采取有效的同步手段，比如，加锁。

以上三个关键点构成了 ABA 问题的充分条件，我们只需要打破其中一个条件就可以解决 ABA 问
题。 

解决方法：

1、最暴力的解决方法就是在转账操作的时候，进行加锁，这样就不会出现别的线程横插一脚了。 

2、在每次的CAS操作中，加入一个正向递增的值，这样即使发生上述情况，下一次去判断时，和上一次的结果就会不一样，最终就不会执行成功或者会更新为最新的情况。这个正向递增的值，可以采用：版本号与时间戳。

好啦！本期 初始JavaEE篇——多线程（7）：定时器、CAS 的学习之旅就到此结束啦！我们下一期再一起学习吧！