1 原子类
Java.util.concurrent.atomic
2 没有CAS之前
多线程环境中不使用原子类保证线程安全i++(基本数据类型)
常用synchronized
锁,但是它比较重 ,牵扯到了用户态和内核态的切换,效率不高。
public class T3
{
volatile int number = 0;
//读取
public int getNumber()
{
return number;
}
//写入加锁保证原子性
public synchronized void setNumber()
{
number++;
}
}
3 使用CAS之后
- 多线程情况下使用原子类保证线程安全(基本数据类型)
public class T3
{
volatile int number = 0;
//读取
public int getNumber()
{
return number;
}
//写入加锁保证原子性
public synchronized void setNumber()
{
number++;
}
//=================================
//下面是新版本
//=================================
AtomicInteger atomicInteger = new AtomicInteger();
public int getAtomicInteger()
{
return atomicInteger.get();
}
public void setAtomicInteger()
{
atomicInteger.getAndIncrement();//先读再加
}
}
- 类似于乐观锁
4 CAS是什么?
4.1 CAS基本知识
compare and swap的缩写,中文翻译成比较并交换,实现并发算法时常用到的一种技术。它包含三个操作数——内存位置、预期原值及更新值。
执行CAS操作的时候,将内存位置的值与预期原值比较:
如果相匹配,那么处理器会自动将该位置值更新为新值,
如果不匹配,处理器不做任何操作,多个线程同时执行CAS操作只有一个会成功。
4.2 CAS原理
CAS (CompareAndSwap)
CAS有3个操作数,位置内存值V,旧的预期值A,要修改的更新值B。
当且仅当旧的预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做或重来*
当它重来重试的这种行为成为—自旋!
4.3 CAS Demo代码
多线程情况下使用原子类保证线程安全(基本数据类型)
public class CASDemo
{
public static void main(String[] args) throws InterruptedException
{
AtomicInteger atomicInteger = new AtomicInteger(5);
System.out.println(atomicInteger.compareAndSet(5, 2022)+"\t"+atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(5, 1024)+"\t"+atomicInteger.get());
}
}
//true 2022
//false 2022
注意:compareAndSet方法有两个参数,第一个参数是希望当前的atomicInterger是多少 (一般就是我们从主内存中拿取当前atomicInterger时候的值) ,第二个参数是希望修改为多少,如果当前atomicInterger的值是我们希望的值,就会修改为我们希望修改的值,反之不会修改。
4.4 硬件级别的保证
CAS是JDK提供的非阻塞原子性操作,它通过硬件保证了比较-更新的原子性
它是非阻塞的且自身具有原子性,也就是说这玩意效率更高,因为它不用加synchronized这样的重锁,不涉及用户态和内核态的切换(synchronized是基于底层操作系统的Mutex Lock实现的,每次获取和释放锁都会带来用户态和内核态的切换)且通过CPU源语级别的硬件保证,说明这玩意更可靠
CAS是一条CPU的原子指令 (cmpxchg指令),不会造成所谓的数据不一致问题,Unsafe类提供的CAS方法(如compareAndSwapXXX)底层实现即为CPU指令cmpxchg。执行cmpxchg指令的时候,会判断当前系统是否为多核系统,如果是就给总线加锁,只有一个线程会对总线加锁成功 (也就是说只会有一个线程进来),加锁成功之后会执行cas操作,也就是说CAS的原子性实际上是CPU实现独占的,比起用synchronized重量级锁, 这里的排他时间要短很多, 所以在多线程情况下性能会比较好。
4.5 源码分析
private static final Unsafe unsafe = Unsafe.getUnsafe();
//compareAndSet
//发现它调用了Unsafe类
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
//compareAndSwapInt
//发现它调用了native方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
//这三个方法是类似的
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
上面Unsafe类的三个方法都是类似的,主要对4个参数做一下说明:
var1:表示要操作的对象
var2:表示要操作对象中属性地址的偏移量
var4:表示需要修改数据期望的值
var5/var6:表示需要修改为的新值
atomicInterger原子类为什么好用,底层就是因为用的是UnSafe类!
引出来一个问题:Unsafe类是什么
ps:面试时,需要懂Unsafe类,因为说白了原子类靠的是CAS思想,CAS思想落地实现靠Unsafe类的CPU源语级别的汇编操作,但是工作中不要用Unsafe类,因为用不好容易导致内存混乱
5 CAS底层原理?如果知道,谈谈你对UnSafe的理解
5.1 UnSafe
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;//保证变量修改后多线程之间的可见性
}
注:valueOffset = unsafe.objectFieldOffset
获取对象在内存中的偏移地址,并赋值给valueOffset
1 Unsafe
CAS这个理念 ,落地就是Unsafe类
它是CAS的核心类,由于Java方法无法直接访问底层系统,需要通过本地(native)方法来访问,Unsafe相当于一个后门 ,基于该类可以直接操作特定内存的数据 。Unsafe类存在于sun.misc包中,其内部方法操作可以像C的指针一样直接操作内存,因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意:Unsafe类中的所有方法都是native修饰的,也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务 。
打开rt.jar包(最基本的包)
2 变量valueOffset
,表示该变量值在内存中的偏移地址,因为Unsafe就是根据内存偏移地址获取数据的
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
3 变量value用volatile修饰
5.2 源码分析
new AtomicInteger().getAndIncrement();
//AtomicInteger.java
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
//Unsafe.class
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
//Unsafe.class
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
说明:
- 变量valueOffset,表示该变量值在内存中的偏移地址,因为Unsafe类就是根据内存偏移地址获取数据的
- 变量value用volatile修饰,保证了多线程之间的内存可见性(也就是说哪个线程调用了getAndIncrement方法把最新的值加了1,其他线程都能感知到!)
- getAndAddInt方法中的do while就是在自旋,直到成功为止。
我们知道i++线程不安全的,那atomicInteger.getAndIncrement()如何保证原子性?
CAS的全称为Compare-And-Swap,它是一条CPU并发原语。
它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的。
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作,从而避免 synchronized 的高开销,执行效率大为提升。
CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法,JVM会帮我们实现出CAS汇编指令 。这是一种完全依赖于硬件的功能,通过它实现了原子操作。再次强调,由于CAS是一种系统原语 ,原语属于操作系统用语范畴,是由若干条指令组成的,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致问题。
总结
- 你只需要记住:CAS是靠硬件实现的从而在硬件层面提升效率,最底层还是交给硬件来保证原子性和可见性
- 实现方式是基于硬件平台的汇编指令,在intel的CPU中(X86机器上),使用的是汇编指令cmpxchg指令。
- 核心思想就是:比较要更新变量的值V和预期值E(compare),相等才会将V的值设为新值N(swap)如果不相等自旋再来。
标签:JUC,CAS,编程,Unsafe,final,int,内存,public From: https://blog.csdn.net/qq_64064246/article/details/139330409