JavaEE:多线程进阶(CAS)

月临水

已于 2024-10-06 20:02:52 修改

阅读量2.2k

点赞数 43

分类专栏： # JavaEE Java 文章标签： java-ee java 开发语言

于 2024-09-05 16:45:51 首次发布

本文链接：https://blog.csdn.net/qrwitu142857/article/details/141791667

版权

Java 同时被 2 个专栏收录

52 篇文章 0 订阅

订阅专栏

JavaEE

38 篇文章 0 订阅

订阅专栏

文章目录

CAS

什么是 CAS

CAS: 全称Compare and swap，字面意思:”比较并交换“，一个 CAS 涉及到以下操作:

我们假设内存中的原数据V，旧的预期值A，需要修改的新值B。

比较 A 与 V 是否相等。（比较）
如果比较相等，将 B 写入V。（交换）
返回操作是否成功。

CAS 伪代码

下面写的代码不是原子的, 真实的 CAS 是⼀个原子的硬件指令完成的. 这个伪代码只是辅助理解 CAS的工作流程.

    boolean CAS(address, expectValue, swapValue) {
        if (&address == expectedValue){
            &address = swapValue;
            return true;
        }
        return false;
    }

两种典型的不是"原子性"的代码:

check and set (if 判定然后设定值)[上面的CAS就是这种形式]
read and update (i++)

当多个线程同时对某个资源进行CAS操作,只能有一个线程操作成功,但是并不会阻塞其他线程,其他线程只会收到操作失败的信号.

CAS是乐观锁的一种实现方式

CAS有哪些应用

实现原子类
标准库中提供了java.util.concurrent.atomic包,里面的类都是这种方式来实现的.
在这里插入图片描述

private static AtomicInteger sum = new AtomicInteger();

public static void main(String[] args) throws InterruptedException {

    Thread t1 = new Thread(()->{
        for (int i = 0; i < 50000; i++) {
            sum.getAndIncrement(); // sum++
            sum.incrementAndGet(); // ++sum
            sum.getAndDecrement(); //sum--
            sum.decrementAndGet(); // --sum
            sum.getAndAdd(10); // sum += 10
        }
    });
    Thread t2 = new Thread(()->{
        for (int i = 0; i < 50000; i++) {
            sum.getAndIncrement();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    // 通过 sum.get() 来拿到原子类内部持有的真是数据.
    System.out.println(sum.get());
}

典型的就是AtomicInteger类,其中的getAndIncrement相当于i++操作

AtomicInteger atomicInteger = new AtomicInteger(0);
// 相当于 i++
atomicInteger.getAndIncrement();

伪代码实现:

class AtomicInteger {
	private int value;

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

假设两个线程同时调用getAndIncrement
1. 两个线程都读取value的值到oldValue中.(oldValue是一个局部变量,在栈上,每个线程有自己的栈)
在这里插入图片描述
2. 线程1先执行CAS操作.由于oldValue和value的值相同,直接进行对value赋值.

CAS是直接读写内存的,而不是操作寄存器.
CAS的读内存,比较,写内存操作是一条硬件指令,是原子的.

在这里插入图片描述
3. 线程2再执行CAS操作,第一次CAS的时候发现oldValue和value不相等,不能进行赋值,因此需要进入循环.
在循环里重新获取value的值赋给oldValue

4. 线程2接下来第二次执行CAS,此时oldValue和value相同,于是直接执行赋值操作.
在这里插入图片描述
5. 线程1和线程2返回各自的oldValue的值即可.
通过形如上述代码就可以实现一个原子类.不需要使用重量级锁,就可以高效的完成多线程的自增操作.

本来check and set 这样的操作在代码角度不是原子的,但是在硬件层面上可以让一条指令完成这个操作,也就变成原子的了

实现自旋锁
基于CAS实现更灵活的锁,获取到更多的控制权.
自旋锁伪代码

public class SpinLock {
	private Thread owner = null;
	public void lock(){
		// 通过 CAS 看当前锁是否被某个线程持有. 
		// 如果这个锁已经被别的线程持有, 那么就⾃旋等待. 
		// 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程. 
		while(!CAS(this.owner, null, 	Thread.currentThread())){
		}
	}
	public void unlock (){
 		this.owner = null;
 	}
}