600字范文 > Java 并发编程CAS volatile synchronized原理详解

Java 并发编程CAS volatile synchronized原理详解

时间：2023-08-05 05:54:50

CAS（CompareAndSwap）

什么是CAS？

在Java中调用的是Unsafe的如下方法来CAS修改对象int属性的值（借助C来调用CPU底层指令实现的）：

/*** * @param o 对象所在类本身的对象（一般这里是对一个对象的属性做修改，才会出现并发）* @param offset 属性在对象中的相对偏移量位置（获取偏移量也是通过unsafe的⼀个⽅法： objectFieldOffset(Fieldfield)来获取属性在对象中的偏移量；）* @param expected 修改前期待的值，原来的值和修改之前的值需要一致* @param x 修改的目标值* @return 修改是否成功*/public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

对象的引用进行比较后交换，交换成功则返回true，交换失败返回false

为什么需要CAS？

CAS能够保证性能的同时保证数据的可见性，可以说是一个非阻塞的轻量级锁，性能高于synchronized

CAS 原理

执行逻辑类似：

if (this == expect) {this = updatereturn true;} else {return false;}

交换过程完全是原子的，基本流程如下：

在CPU上计算完结果后，都会对比内存的结果是否还是原先的值如果不是原先的值，则认为已被其它线程修改，不能替换如果是原先的值，则认为没有其它线程去修改，则可以修改，因为变量是volatile类型，所以最终写入的数据会被其它线程看到，所以一个线程修改成功后，其它线程就发现自己修改失败了重新尝试修改

这明明是好几步的操作，怎么会是原子操作呢？

整体过程：Java通过JNI来调用native方法，而native方法的实现是C，C调用的是CPU底层指令实现。

在CPU底层指令中，是通过加锁的方式实现，实现方式有如下三种：

处理器自动保证基本内存操作的原子性：一个处理器访问某一个字节时，其它处理器不能访问这个字节的内存地址使用总线锁保证原子性：当一个处理器在总线上输出LOCK#信号时，其它处理器的请求将被阻塞，那么该处理器可以独占使用共享内存缓存锁保证原子性：频繁使用的内存会缓存在处理器的L1、L2、L3高速缓存中，那么原子操作可以直接在处理器内部缓存中进行，不需要声总线锁。当一个处理器修改缓存行中的i变量使用缓存锁定，那么其它处理器就不能同时缓存i变量的缓存行

CAS 优缺点

优点：

高性能：无锁的方式实现原子操作使用简单：调用compareAndSwapxx()方法即可实现

缺点:

ABA问题：由于CAS是检测值是否被改变，但一个变量的值原来是A，然后修改成B，然后又修改成A，这是实际上变量已被修改，但CAS检查的时候会发现它的值没有发生变化，还是能够被正常的CAS。解决思路就是通过对变量增加版本号，没修改一次版本号加1，所有原本ABA就是1A-2B-3A。在atomic包提供了一个类AtomicStampedReference就是采用类似的思路解决ABA问题循环时间长开销大：在CAS更新失败会进入自旋，一旦长时间更新失败，就会占用较多的CPU只能保证一个共享变量的原子操作：在只有一个变量的时候，可以使用CAS来保证原子操作，但如果有多个变量，CAS无法保证操作的原子性。解决方案就是用锁来保证多个变量的原子性；也可以使用位的方式，将多个变量合并成一个变量进行CAS操作，如x&F0|y&0F

CAS 应用

我们拿java.util.concurrent.atomic.AtomicInteger举例：

public class AtomicInteger extends Number implements java.io.Serializable {// setup to use pareAndSwapInt for updatesprivate static final Unsafe unsafe = Unsafe.getUnsafe();private static final long valueOffset;static {try {// 属性在这个对象⾥⾯的相对偏移量位置valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) {throw new Error(ex);}}// 要更新的变量private volatile int value;/*** Creates a new AtomicInteger with the given initial value.** @param initialValue the initial value*/public AtomicInteger(int initialValue) {value = initialValue;}/*** 如果当前值是期望值expect，则原子地将值设置为给定的更新值update** @param expect 期望值* @param update 更新值* @return 如果true表示更新成功，false表示实际值不等于期望值*/public final boolean compareAndSet(int expect, int update) {return pareAndSwapInt(this, valueOffset, expect, update);}/*** 将当前值原子的加1** @return the 加1之前的值*/public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);}...}

java.util.concurrent.atomic包中Atomic*基本都是使用相同的思路来实现原子操作的

volatile

volatile的主要作用是：

可见性：保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这个新值对其它线程来说是立即可见的有序性：禁止指令重排序

volatile 可见性

可见性表示一个变量的值被更新后，是否能够在每个线程中可见

public class ExampleVisibility {private boolean stop = false;private void stop() {this.stop = true;}private void run() {while (!stop) {// run}System.out.println("stop!!");}public static void main(String[] args) throws InterruptedException {ExampleVisibility self = new ExampleVisibility();new Thread(() -> {self.run();}).start();Thread.sleep(1000 * 4);new Thread(() -> {// 停止whileself.stop();}).start();}}

执行多次，你会发现有的时候无法停止while，也就是stop一直为false

问题原因：

在cpu中有多级cache，如果每次在内存中取效率不高，所有cpu中有自己的cache以提高效率（在缓存中，每个变量在缓存行上都有一个2bit的状态，那就是CPU EMSI协议）

有如下两种可能原因：

线程将变量stop修改后没有更新到主存中stop在cpu一级缓存或二级缓存有缓存，当线程要读取stop变量的时候发现已存在缓存中，没有再去主存中重新读取stop变量

解决方案：

在stop变量中增加volatile关键字保证可见性

private volatile boolean stop = false;

volatile 有序性

volatile在一定程度上保证有序性。其中主要就是通过禁止指令重排的方式实现有序性

指令重排序是编译器和处理器为了高效对程序进行优化的手段，它只能保证程序执行的结果是正确的，但是无法保证程序的操作顺序与代码顺序一致。这在单线程中不会构成问题，但是在多线程中就会出现问题。

代码转换为机器执行的指令所经过的步骤：

流水线优化问题：

在cpu内部不同的操作是由不同的硬件来做，比如专门ADD操作的硬件、INC的硬件、MOV的硬件，它们之间同时执行多个指令，上一级处理完成流到下一级，所以叫做流水线

在未排序之前需要阻塞等待ADD指令完成写入后INC才能继续执行，INC执行后才能MOV

在重排序之后，先执行了MOV，然后INC，指令之间没有阻塞（一般的重排序不会对结果产生影响）

public class ExampleReordering {private static int x = 0, y = 0;private static int a = 0, b = 0;public static void main(String[] args) throws InterruptedException {int count = 0;while (true) {count++;x = 0;y = 0;a = 0;b = 0;//clearThread one = new Thread(new Runnable() {public void run() {shortWait(100000);a = 1;x = b;}});Thread other = new Thread(new Runnable() {public void run() {b = 1;y = a;}});one.start();other.start();one.join();other.join();String result = "第" + count + "次 (" + x + "," + y + "）";if (x == 0 && y == 0) {System.err.println(result);break;} else {System.out.println(result);}}}public static void shortWait(long interval) {long start = System.nanoTime();long end;do {end = System.nanoTime();} while (start + interval >= end);}}

代码正确执行情况下，x和y不会同时等于0，在指令重排序的情况下，就可能发生x和y都等于0的异常情况

解决方案：

在每个变量中增加volatile关键字禁止指令重排序

private volatile static int x = 0, y = 0;private volatile static int a = 0, b = 0;

volatile 原理

在对比加入volatile关键字与未加入volatile关键字所生成的汇编代码发现，加入volatile关键字时会多出一个lock前缀指令，lock前缀指令相当于一个内存屏障（或内存栅栏），内存屏障主要提供如下功能：

确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障之后；volatile会强制将对缓存的修改操作立即写入主内存如果是写操作的时候，volatile会导致其它CPU中对应的此缓存行失效

volatile 应用

synchronized关键字是防止多个线程执行同一段代码，而volatile作用却不同，使用前需要具备如下两个条件：

对变量的写操作不依赖于当前变量的值该变量没有包含在具有其它变量的不变式中

volatile能保证原子性吗？

不能，volatile关键字保证了操作的可见性，但无法保证变量操作的原子性，原因如下：

在多个线程对i变量进行i++操作时，实际上需要做如上4步，在线程A还没有将add后的i值putfield，上下文就切换到了线程B，线程B执行了add操作。

两个线程同时对一个老的i进行add，所有原来应该+2的变成只有+1，最终导致数据的偏差。

解决方案：在incr()方法中增加synchronized关键字

private synchronized void incr() {i++;}

synchronized

什么是synchronized？

是一种同步锁，通过synchronized对方法或代码块修饰，确保多个线程在同一个时刻，只能有一个线程处于方法/代码块中，它确保了线程对变量访问的可见性和排他性

synchronized 实现原理

JVM是通过进入、退出对象监视器（Monitor）来实现对方法、同步块的同步的；而对象监视器的本质依赖于底层操作系统的互斥锁（Mutex Lock）实现。

基本过程：

代码编译之后会在同步方法调用前加入一条monitor.enter指令，在退出方法和异常处插入monitor.exit指令当有一个线程进入后会获取锁（Mutex Lock），如果有另一个线程调用方法，则会阻塞在方法入口处，直到获取锁的线程monitor.exit之后才能继续尝试获取锁

synchronized 锁升级过程

在JDK1.6之前，synchronized是一个重量级锁，开销很大，所以经常被建议说少用点。

但在JDK1.6之后，该关键字进行了很多的优化，主要就是锁升级，会自动根据不同的资源竞争情况升级锁（锁膨胀）。

锁升级过程：

偏向锁：是指一段同步代码一直被一个线程所访问，假如该锁没有被其他线程所获取，没有其他线程来竞争该锁，那么持有偏向锁的线程将永远不需要进行同步操作。降低获取锁的代价。轻量级锁：是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能（比如自旋锁）。重量级锁：是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞（对象监视器Monitor），性能降低。

synchronized 应用

synchronized 有如下四种方式修饰对象来实现代码同步：

修饰一个代码块，对象锁，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；修饰一个方法，对象锁，其作用的范围是整个方法，作用的对象是调用这个方法的对象；修饰一个静态的方法，类锁，其作用的对象是这个类的所有对象；修饰一个类，类锁，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象；示例代码：

package com.muse.thread;import java.util.concurrent.TimeUnit;public class SynchronizedDemo {public static void main(String[] args) {/** case1：无Synchronized，乱序输出 */// NoneSyncDemo noneSyncDemo = new NoneSyncDemo();// Thread thread1 = new Thread(noneSyncDemo);// Thread thread2 = new Thread(noneSyncDemo);/** case2：synchronized修饰代码块, 对象锁 */// 加锁有效// SyncBlockDemo syncBlockDemo = new SyncBlockDemo();// Thread thread1 = new Thread(syncBlockDemo);// Thread thread2 = new Thread(syncBlockDemo);// 加锁无效// SyncBlockDemo syncBlockDemo1 = new SyncBlockDemo();// SyncBlockDemo syncBlockDemo2 = new SyncBlockDemo();// Thread thread1 = new Thread(syncBlockDemo1);// Thread thread2 = new Thread(syncBlockDemo2);/** case3：synchronized修饰方法，对象锁 */// 加锁有效// SyncMethodDemo syncMethodDemo = new SyncMethodDemo();// Thread thread1 = new Thread(syncMethodDemo);// Thread thread2 = new Thread(syncMethodDemo);// 加锁无效// SyncMethodDemo syncMethodDemo1 = new SyncMethodDemo();// SyncMethodDemo syncMethodDemo2 = new SyncMethodDemo();// Thread thread1 = new Thread(syncMethodDemo1);// Thread thread2 = new Thread(syncMethodDemo2);/** case4：synchronized修饰静态方法，类锁 */// 加锁有效// SyncStaticMethodDemo syncStaticMethodDemo = new SyncStaticMethodDemo();// Thread thread1 = new Thread(syncStaticMethodDemo);// Thread thread2 = new Thread(syncStaticMethodDemo);// 加锁有效// SyncStaticMethodDemo syncStaticMethodDemo1 = new SyncStaticMethodDemo();// SyncStaticMethodDemo syncStaticMethodDemo2 = new SyncStaticMethodDemo();// Thread thread1 = new Thread(syncStaticMethodDemo1);// Thread thread2 = new Thread(syncStaticMethodDemo2);/** case5：synchronized修饰类，类锁 */// 加锁有效// SyncClassDemo syncClassDemo = new SyncClassDemo();// Thread thread1 = new Thread(syncClassDemo);// Thread thread2 = new Thread(syncClassDemo);// 加锁有效SyncClassDemo syncClassDemo1 = new SyncClassDemo();SyncClassDemo syncClassDemo2 = new SyncClassDemo();Thread thread1 = new Thread(syncClassDemo1);Thread thread2 = new Thread(syncClassDemo2);thread1.start();thread2.start();}}/*** [case1：无Synchronized]*/class NoneSyncDemo implements Runnable {@Overridepublic void run() {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + i);TimeUnit.MILLISECONDS.sleep(100);} catch (Throwable e) {e.printStackTrace();}}}}/*** [case2：synchronized修饰代码块]* 一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。**/class SyncBlockDemo implements Runnable {@Overridepublic void run() {synchronized(this) {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + i);TimeUnit.MILLISECONDS.sleep(200);} catch (Throwable e) {e.printStackTrace();}}}}}/*** [case3：synchronized修饰方法]* 一个线程访问一个对象中的synchronized修饰的方法时，其他试图访问该对象的线程将被阻塞。**/class SyncMethodDemo implements Runnable {@Overridepublic synchronized void run() {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + i);TimeUnit.MILLISECONDS.sleep(200);} catch (Throwable e) {e.printStackTrace();}}}}/*** [case4：synchronized修饰静态方法]* 修饰一个静态的方法，类锁，其作用的对象是这个类的所有对象；**/class SyncStaticMethodDemo implements Runnable {@Overridepublic void run() {method();}public synchronized static void method() {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + i);TimeUnit.MILLISECONDS.sleep(200);} catch (Throwable e) {e.printStackTrace();}}}}/*** [case5：synchronized修饰类]* 修饰一个类，类锁，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象；**/class SyncClassDemo implements Runnable {@Overridepublic void run() {synchronized(SyncClassDemo.class) {for (int i = 0; i < 5; i++) {try {System.out.println(Thread.currentThread().getName() + ":" + i);TimeUnit.MILLISECONDS.sleep(200);} catch (Throwable e) {e.printStackTrace();}}}}}