[Java EE] 多线程(八):CAS问题与JUC包-易微帮

🌸个人主页:https://blog.csdn.net/2301_80050796?spm=1000.2115.3001.5343
🏵️热门专栏:🍕 Collection与数据结构 (90平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm=1001.2014.3001.5482
🧀Java EE(94平均质量分) https://blog.csdn.net/2301_80050796/category_12643370.html?spm=1001.2014.3001.5482
🍭MySql数据库(93平均质量分)https://blog.csdn.net/2301_80050796/category_12629890.html?spm=1001.2014.3001.5482
感谢点赞与关注~~~

1. CAS问题

1.1 什么是CAS

CAS全程compare and swap,字面意思就是比较和交换(与其说是交换,不如说是赋值),在底层会涉及到一下操作.
底层中涉及到的对象有内存和两个寄存器.

首先比较内存地址中的值和寄存器1的值是否相等.
如果相等,把寄存器2中的值赋给内存中.
如果不相等,不进行任何操作
返回值为是否赋值成功.
注意:上述的操作为原子操作.

1.2 伪代码

注意:下面的代码不是原子的,只是用于辅助理解CAS的过程,实际的CAS问题在硬件底层中是原子的.

boolean CAS(address,expectValue,swapValue){//address内存中的值,expectValue寄存器1,swapValue寄存器2
	if(address == expectValue){
		address = swapValue;
		return true;
	}
	return false;
}

1.3 CAS是如何实现的

简而言之,是因为硬件方面提供了支持,软件层面才可以做到.由CPU提供了上述指令,因此操作系统内核也能够完成这样的操作,之后OS会提供出响应的api,JVM对OS提供出的api进行封装,我们便可以在Java中使用CAS.

1.4 CAS的有哪些应用

1.4.1 实现原子类

标准库中提供了java.util.concurrent.atomic 包,里面的类都是基于这种方式来实现的.
典型的就是AtomicInteger类.其中的getAndIncrement相当于i++操作.

该类的构造方法可以指定一开始变量的初始值.
increamentAndGet --> ++i
getAndIncrement–> i++
decreamentAndGet --> --i
getAndDecreament --> i–
getAndAdd(10) --> i+=10

import java.util.concurrent.atomic.AtomicInteger;

public class Demo26 {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        Thread thread = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                atomicInteger.incrementAndGet();
            }
        });
        Thread thread1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                atomicInteger.incrementAndGet();
            }
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(atomicInteger);
    }
}

运行结果:
在这里插入图片描述
伪代码实现

class AtomicIntegter{
	private int value;
	
	public int getAndIncrement(){
		int oldValue = value;
		while (!CAS(value,oldValue,oldValue+1)){
			oldValue = value;
		}
		return oldValue;
	}
}

总地来说,原子类没有用到任何的加锁操作(是因为CAS没有用到加锁),使得代码的效率更高,但是这种共操作只适用于部分场景,加锁的使用场景还是比原子类更加通用.

1.4.2 实现自旋锁

伪代码实现:

public class SpinLock{
	private Thread owner = null;
	public void lock(){
		while(!CAS(owner,null,Thread.currentThread()){//判断锁是否被占用,没有就使用当前线程赋值
		}
	}
	public void unlock(){
		this.owner = null;//解锁之后赋值为null
	}
}

1.5 CAS的ABA问题

1.5.1 什么是ABA问题

现在存在两个线程,t1线程和t2线程,t1线程要想进行CAS,需要进行一下操作:

先读取num的值,记录到oldNum变量中.
使用CAS判定当前num的值是否为A,如果为A,就修改成Z.
如果有一个线程t2在这个中间对当前num的值进行了修改.只不过就是从A改成了B又一次改回了A.

举例说明:翻新机
这就好比你买来一个新手机,你无法判断这是一个全新的一手手机,还是有一些无良商家对二手机进行了翻新再卖给你.

1.5.2 ABA问题带来的bug

大部分情况下,ABA问题不会造成什么bug,但是不排除出现一些特殊情况会出现bug.

举例说明:钟离去银行取钱
有请助教:钟离,达达利亚

正常的过程:
t1线程希望从总结金额100中扣款50,这时候t2线程也希望如此,假设t1先进行了CAS操作,t2阻塞等待,t1线程的CAS操作把new值赋值为old-50之后,new值就变为50.之后在t2进行CAS操作的时候,t2就发现new值和old值不一样,就不会进行CAS操作.

异常的情况
在钟离取款的时候,由于达达利亚考虑到钟离每次都可能不带钱,所以在钟离取款的时候,达达利亚又给钟离打了50块钱.在t1线程执行完CAS操作之后,t2还没有执行CAS,这时候进行了打款操作,t2进行CAS操作的时候,认为old值和new值相等,所以t2也进行了一次扣款操作.这时候就产生了bug.

1.5.3 解决方案

要给修改的值引入版本号.版本号只加不减,每次操作一次余额之后,版本号+=1.在CAS⽐较数据当前值和旧值的同时,也要⽐较版本号是否符合预期.

在CAS操作在读取旧值的时候,也要读取版本号.
在真正修改的时候:
- 如果当前版本号和读到的版本号一样的时候,修改数据.
- 如果当前版本号高于读到的版本号的时候,就操作失败了.

继续拿前面的钟离取款的例子来说明:
在t1线程进行CAS的时候,进行了扣款操作,版本号+1,之后t3线程进行打款,对版本号+1,之后在t2线程CAS的时候,发现当前版本号高于之前读取到的版本号,则操作失败.

2. JUC包

JUC包,全称java.util.concurrent.其中存放了和多线程相关的组件.

2.1 Callable接口

该接口和Runnable相同,是描述一个任务的,只不过call方法有返回值,而run方法没有返回值.就是相当于给线程封装了一个返回值.
代码实例:计算1+2+3+…+1000的值

不使用Callable的接口

public class Demo28 {
    private static int sum = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            int result = 0;
            for (int i = 0; i < 1000; i++) {
                result += i;
            }
            sum = result;
        });
        thread.start();
        thread.join();
        System.out.println(sum);
    }
}

使用Callable接口

创建一个匿名类,实现Callable接口的call方法,方法中是累加过程,泛型参数表示返回值的类型.
把callable实例用FutureTask来包装一下,引用设置为futureTask.
创建线程,构造方法传入futureTask,启动线程.
之后通过futureTask的get方法去获取到call方法的返回值.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo27 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int ret = 0;
                for (int i = 0; i < 5000; i++) {
                    ret++;
                }
                return ret;
            }
        };//通过匿名内部类的方法重写call方法
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        //通过FutureTask来包装callable
        Thread thread = new Thread(futureTask);
        thread.start();//线程开始执行任务
        thread.join();
        System.out.println(futureTask.get());//通过futureTask的get方法;来拿到call的返回值
    }
}

运行结果:
在这里插入图片描述

举例说明:
有请助教:香菱,莱欧斯利
今天,莱欧斯利去万名堂吃饭,万名堂的前台招待员为莱欧斯利点好餐之后,就会产生一个菜单(call方法中的一堆东西),之后会生成小票(futureTask),小票一份值后厨联,一份是顾客联,之后后厨联的小票就会传到香菱的手中(把futureTask传给线程),香菱就会在后厨一通输出,在香菱做好之后,莱欧斯利就可以通过顾客联取到餐(get方法).

[Java EE] 多线程(八):CAS问题与JUC包