找往期文章包括但不限于本期文章中不懂的知识点:
个人主页:我要学编程程(ಥ_ಥ)-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 的学习之旅就到此结束啦!我们下一期再一起学习吧!