java Unsafe类的compareAndSwap方法

本文详细介绍了Java中Unsafe类的基本原理及其提供的compareAndSwap方法,包括原子操作、性能优势以及如何通过反射获取Unsafe实例进行属性偏移获取和字段修改。通过示例代码展示了如何利用Unsafe类进行高效且原子性的对象属性修改。
compareAndSwap是个原子方法,原理是cas.就是说如果他是xx,那么就改为xxx. 
这个是高效,而且是原子的,不用加锁. 
也不用但是其他值改了而产生误操作,应为会先判断当前值,符合期望才去改变. 

直接上代码吧
 

Java代码  收藏代码
  1. package com.huangyunbin;  
  2. import java.lang.reflect.Field;  
  3. import sun.misc.Unsafe;  
  4.   
  5.   
  6. public class UnsafeTest {  
  7.   
  8.     private static Unsafe unsafe;  
  9.   
  10.     static {  
  11.         try {  
  12.             //通过反射获取rt.jar下的Unsafe类  
  13.             Field field = Unsafe.class.getDeclaredField("theUnsafe");  
  14.             field.setAccessible(true);  
  15.             unsafe = (Unsafe) field.get(null);  
  16.         } catch (Exception e) {  
  17.             System.out.println("Get Unsafe instance occur error"+ e);  
  18.         }  
  19.     }  
  20.   
  21.   
  22.   
  23.   
  24.     public static void main(String[] args) throws Exception  
  25.     {  
  26.         Class clazz = Target.class;  
  27.         Field[] fields = clazz.getDeclaredFields();  
  28.         System.out.println("fieldName:fieldOffset");  
  29.         for (Field f : fields) {  
  30.             // 获取属性偏移量,可以通过这个偏移量给属性设置  
  31.             System.out.println(f.getName() + ":" + unsafe.objectFieldOffset(f));  
  32.         }  
  33.         Target target = new Target();  
  34.         Field intFiled  =  clazz.getDeclaredField("intParam")  ;  
  35.         int a=(Integer)intFiled.get(target ) ;  
  36.         System.out.println("原始值是:"+a);  
  37.         //intParam的字段偏移是12 原始值是3 我们要改为10  
  38.         System.out.println(unsafe.compareAndSwapInt(target, 12310));  
  39.         int b=(Integer)intFiled.get(target) ;  
  40.         System.out.println("改变之后的值是:"+b);  
  41.   
  42.         //这个时候已经改为10了,所以会返回false  
  43.         System.out.println(unsafe.compareAndSwapInt(target, 12310));  
  44.   
  45.         System.out.println(unsafe.compareAndSwapObject(target, 24null"5"));  
  46.     }  
  47. }  
  48.   
  49.   
  50.  class Target {  
  51.      int intParam=3;  
  52.      long longParam;  
  53.      String strParam;  
  54.      String strParam2;  
  55. }  


结果是: 
fieldName:fieldOffset 
intParam:12 
longParam:16 
strParam:24 
strParam2:28 
原始值是:3 
true 
改变之后的值是:10 
false 
true
 

compareAndSwapInt是通过反射根据字段偏移去修改对象的. 
可以看到int是4个字节的偏移量,long是4个字节的偏移量,string是4个字节的偏移量 
注意 Unsafe的对象不能直接new,要通过反射去获取.
<think>嗯,用户让我介绍一下Java中的Compare and Swap(CAS)机制。首先,我需要回想一下CAS的基本概念。CAS是一种并发编程中常用的技术,用于实现无锁的数据结构,避免使用传统的锁机制,从而提高性能。Java中的CAS操作主要是在java.util.concurrent包中的里使用,比如AtomicInteger、AtomicLong等原子。 接下来,我要确定用户可能的知识背景。可能用户已经了解多线程编程的基本概念,比如线程安全、竞态条件等,但可能对具体的无锁机制不太熟悉。需要解释清楚CAS的工作原理,以及它在Java中的具体应用。 然后,我应该解释CAS的三个操作数:内存位置V,旧的预期值A,和新值B。当执行CAS操作时,只有当V的值等于A时,才会将V的值更新为B,否则不进行任何操作。无论是否更新,都会返回V原来的值。这个过程是原子性的,由底层硬件支持,比如通过CPU的CAS指令实现,比如在Intel处理器中的CMPXCHG指令。 需要强调CAS的优点,比如避免线程阻塞,减少上下文切换,提高高并发场景下的性能。但也要提到它的缺点,比如ABA问题。ABA问题是指一个值原来是A,被改为B,然后又改回A,这时候CAS检查时会认为值没有变化,但实际上可能发生了其他操作。为了解决这个问题,Java提供了AtomicStampedReference和AtomicMarkableReference,通过引入版本号或标记来避免ABA问题。 接下来,可能需要给出一个Java中使用CAS的例子,比如AtomicInteger的incrementAndGet方法,内部就是通过CAS实现的。可以展示一下代码示例,说明如何通过循环不断尝试更新,直到成功为止。 另外,用户可能想知道CASJava中的底层实现,比如Unsafe的使用,但要注意从Java 9开始,Unsafe被逐渐限制使用,转而使用VarHandle等更安全的API。不过大部分情况下,开发者直接使用原子即可,无需关心底层实现。 还要考虑用户可能的疑问,比如为什么CAS比锁更高效。锁会导致线程挂起和恢复,涉及内核态的操作,而CAS在用户态完成,没有线程切换的开销。不过在高竞争的情况下,CAS可能导致大量重试,消耗CPU资源,这时候可能锁更适合。 最后,总结CAS的应用场景,比如计数器、队列的实现等,以及注意事项,比如ABA问题和自旋时间长的问题。确保用户理解CAS的适用场景和限制。</think>在 Java 中,**Compare and Swap (CAS)** 是一种用于实现无锁并发操作的关键技术。它通过硬件级别的原子指令(如 CPU 的 `CMPXCHG`)保证操作的线程安全性,避免了传统锁机制(如 `synchronized`)带来的上下文切换和阻塞开销。 --- ### **CAS 核心原理** CAS 操作包含三个参数: 1. **内存位置(V)**:要修改的共享变量(如 `AtomicInteger` 的值) 2. **旧的预期值(A)**:线程认为变量当前应该具有的值 3. **新值(B)**:希望将变量更新为的值 **执行过程**: - 如果内存位置 `V` 的当前值等于预期值 `A`,则将 `V` 更新为 `B`,并返回 `true`。 - 否则不修改值,返回 `false`。 整个过程是**原子性**的,由底层硬件直接支持。 --- ### **Java 中的 CAS 实现** Java 通过 `sun.misc.Unsafe` (底层 API)或更高层的原子(如 `AtomicInteger`)封装 CAS 操作: #### 示例:`AtomicInteger` 的自增 ```java AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // 内部通过 CAS 实现自增 ``` 底层 `incrementAndGet()` 的简化逻辑: ```java public final int incrementAndGet() { int expect; do { expect = get(); // 获取当前值 } while (!compareAndSet(expect, expect + 1)); // 循环尝试 CAS return expect + 1; } ``` --- ### **CAS 的优缺点** #### **优点**: 1. **无锁并发**:避免线程阻塞,减少上下文切换,适合高并发场景。 2. **高性能**:在低竞争环境下,效率远高于锁。 #### **缺点**: 1. **ABA 问题**: 如果一个值从 `A` → `B` → `A`,CAS 无法感知中间变化。 **解决方案**:使用 `AtomicStampedReference` 添加版本号标记。 2. **自旋开销**:高竞争时,CAS 失败重试可能导致 CPU 空转。 3. **单变量限制**:只能保证单个变量的原子性,无法处理复合操作。 --- ### **ABA 问题示例** 假设线程 1 读取共享变量值为 `A`,准备将其改为 `B`。在此期间,线程 2 将 `A` → `B` → `A`。线程 1 的 CAS 会误认为变量未变化,导致逻辑错误。 **解决方式**:使用 `AtomicStampedReference` 记录版本号: ```java AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 0); int stamp = ref.getStamp(); ref.compareAndSet(100, 101, stamp, stamp + 1); // 同时检查值和版本号 ``` --- ### **CAS 的应用场景** 1. 原子(如 `AtomicInteger`、`AtomicLong`) 2. 无锁队列(如 `ConcurrentLinkedQueue`) 3. 乐观锁实现(如数据库版本号控制) 4. JUC 工具(如 `CountDownLatch`、`Semaphore` 的底层实现) --- ### **总结** CASJava 实现高效并发的基石,通过硬件原子指令避免了锁的开销,但需注意其适用场景和潜在问题(如 ABA)。实际开发中,优先使用 `java.util.concurrent.atomic` 包中的原子,而非直接操作底层 API。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值