Java里的CompareAndSet(CAS)

Atomic 从JDK5开始, java.util.concurrent包里提供了很多面向并发编程的类. 使用这些类在多核CPU的机器上会有比较好的性能.
主要原因是这些类里面大多使用(失败-重试方式的)乐观锁而不是synchronized方式的悲观锁.

今天有时间跟踪了一下AtomicInteger的incrementAndGet的实现.
本人对并发编程也不是特别了解, 在这里就是做个笔记, 方便以后再深入研究.

1. incrementAndGet的实现

public   final   int  incrementAndGet() {
        
for  (;;) {
            
int  current  =  get();
            
int  next  =  current  +   1 ;
            
if  (compareAndSet(current, next))
                
return  next;
        }
    }


首先可以看到他是通过一个无限循环(spin)直到increment成功为止. 
循环的内容是
1.取得当前值
2.计算+1后的值
3.如果当前值还有效(没有被)的话设置那个+1后的值
4.如果设置没成功(当前值已经无效了即被别的线程改过了), 再从1开始.

2. compareAndSet的实现

  public   final   boolean  compareAndSet( int  expect,  int  update) {
        
return  unsafe.compareAndSwapInt( this , valueOffset, expect, update);
    }


直接调用的是UnSafe这个类的
compareAndSwapInt方法
全称是
sun.misc.Unsafe. 这个类是Oracle(Sun)提供的实现. 可以在别的公司的JDK里就不是这个类了

3.
compareAndSwapInt的实现

  /**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * 
@return  <tt>true</tt> if successful
     
*/
    
public   final   native   boolean  compareAndSwapInt(Object o,  long  offset,
                                                  
int  expected,
                                                  
int  x);


可以看到, 不是用Java实现的, 而是通过JNI调用操作系统的原生程序.

4.
compareAndSwapInt的native实现
如果你下载了OpenJDK的源代码的话在hotspot\src\share\vm\prims\目录下可以找到unsafe.cpp

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv  * env, jobject  unsafe , jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper(
" Unsafe_CompareAndSwapInt " );
  oop p 
=  JNIHandles::resolve(obj);
  jint
*  addr  =  (jint  * ) index_oop_from_field_offset_long(p, offset);
  
return  (jint)(Atomic::cmpxchg(x, addr, e))  ==  e;
UNSAFE_END


可以看到实际上调用
Atomic类的cmpxchg方法.

5.
Atomic的cmpxchg
这个类的实现是跟操作系统有关, 跟CPU架构也有关, 如果是windows下x86的架构
实现在hotspot\src\os_cpu\windows_x86\vm\目录的atomic_windows_x86.inline.hpp文件里

nline jint     Atomic::cmpxchg    (jint     exchange_value,  volatile  jint *      dest, jint     compare_value) {
  
//  alternative for InterlockedCompareExchange
   int  mp  =  os::is_MP();
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}


在这里可以看到是用嵌入的汇编实现的, 关键CPU指令是
cmpxchg
到这里没法再往下找代码了. 也就是说CAS的原子性实际上是CPU实现的. 其实在这一点上还是有排他锁的. 只是比起用synchronized, 这里的排他时间要短的多. 所以在多线程情况下性能会比较好.

代码里有个
alternative for InterlockedCompareExchange
这个
InterlockedCompareExchange是WINAPI里的一个函数, 做的事情和上面这段汇编是一样的
http://msdn.microsoft.com/en-us/library/windows/desktop/ms683560%28v=vs.85%29.aspx

6. 最后再贴一下x86的cmpxchg指定

Opcode CMPXCHG


CPU: I486+
Type of Instruction: User

Instruction: CMPXCHG dest, src

Description: Compares the accumulator with dest. If equal the "dest"
is loaded with "src", otherwise the accumulator is loaded
with "dest".

Flags Affected: AF, CF, OF, PF, SF, ZF

CPU mode: RM,PM,VM,SMM
+++++++++++++++++++++++
Clocks:
CMPXCHG reg, reg 6
CMPXCHG mem, reg 7 (10 if compartion fails)


 

### Java AtomicInteger `compareAndSet` 方法详解 #### 什么是 `compareAndSet`? `compareAndSet` 是 `AtomicInteger` 提供的一个核心方法,用于实现基于比较的操作。该方法接受两个参数:预期值(expected value)和新值(new value)。如果当前内存中的实际值等于预期值,则将此值更新为新值并返回 `true`;否则不会执行任何操作,并返回 `false`。 这种方法的核心在于它的原子性——整个比较和设置过程是一个不可分割的整体,在多线程环境中能够确保数据的一致性和安全性[^2]。 --- #### 方法签名 以下是 `compareAndSet` 的方法签名: ```java public final boolean compareAndSet(int expect, int update) ``` - **expect**: 预期的当前值。 - **update**: 如果期望值匹配成功,则将其替换为此新值。 - 返回值: 如果比较成功则返回 `true`,否则返回 `false`。 --- #### 工作机制 当调用 `compareAndSet(expect, update)` 时,会执行以下逻辑: 1. 获取当前的实际值(current value),即存储在底层变量中的值。 2. 将这个实际值与传入的预期值 (`expect`) 进行对比。 3. 如果两者相等,则将当前值设为新的值 (`update`) 并返回 `true`; 4. 否则不做更改,返回 `false`。 这种机制被称为“CAS(Compare And Swap),它是无锁算法的基础之一,广泛应用于高并发环境下的状态管理[^3]。 --- #### 示例代码 下面展示了一个简单的例子,说明如何使用 `compareAndSet` 来实现线程安全的计数器: ```java import java.util.concurrent.atomic.AtomicInteger; public class CASExample { private AtomicInteger count = new AtomicInteger(0); public void increment() { int currentValue; int newValue; do { currentValue = count.get(); // 获取当前值 newValue = currentValue + 1; // 计算下一个值 } while (!count.compareAndSet(currentValue, newValue)); // 执行 CAS 操作 } public int getCount() { return count.get(); } } ``` 在这个示例中,`increment()` 方法通过循环不断尝试增加计数值。只有当 `compareAndSet` 成功时才会退出循环,这保证了即使有多个线程同时访问也不会发生竞争条件[^1]。 --- #### 实际应用场景 除了基本的计数功能外,`compareAndSet` 可以被用来构建更复杂的同步结构,比如自旋锁或者轻量级信号量。例如,可以利用它创建一个高效的 ID 生产者: ```java public class IdGenerator { private AtomicInteger id = new AtomicInteger(0); public int generateId() { return id.incrementAndGet(); // 自动递增并获取最新ID } } ``` 这展示了另一种方式来简化计数器的设计,其中直接调用了 `incrementAndGet()` 方法完成相同的功能[^4]。 需要注意的是,虽然 `compareAndSet` 很强大,但在某些情况下可能会遇到所谓的 ABA 问题(即某个值先变为 B 再变回 A)。对于这种情况,可以考虑使用扩展类如 `AtomicStampedReference` 来引入版本号控制[^5]。 --- ### 总结 `compareAndSet` 是一种高效且可靠的工具,能够在无需显式锁定的情况下保障共享资源的安全访问。理解其内部运作原理有助于开发者更好地设计高性能的应用程序组件。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值