原子操作：并发编程的基石
原子操作是并发编程中最核心的概念之一，理解它对于编写正确、高效的多线程程序至关重要。
🔬 原子操作的定义
原子操作（Atomic Operation）指的是不可被中断的一个或一系列操作，这些操作要么全部执行成功，要么全部不执行，不存在中间状态。原子操作在多线程环境下是线程安全的，因为其他线程无法看到原子操作的中间状态。
关键特征：
- 不可分割（Indivisible）：操作作为一个整体执行
- 不可中断（Non-interruptible）：执行过程中不会被线程调度打断
- 一致性视图（Consistent View）：其他线程看到的是操作前或操作后的状态，不会看到中间状态
💡 直观理解
想象一个银行转账操作：
// ❌ 非原子操作：分两步执行，可能被中断account.balance=account.balance-100;// 步骤1：扣款recipient.balance=recipient.balance+100;// 步骤2：存款// 如果在步骤1和步骤2之间发生线程切换：// 线程A：执行步骤1（扣款成功）// [线程切换发生]// 线程B：读取account.balance（看到扣款后的余额，但收款方还没收到钱）// 线程B：执行其他操作...（数据不一致！）// ✅ 原子操作：要么全成功，要么全失败atomicTransfer(account,recipient,100);🏗️ 硬件层面的原子操作
1.CPU指令级的原子操作
现代CPU提供了一些原子指令：
; x86架构的原子指令示例 LOCK XADD ; 原子加 LOCK CMPXCHG ; 比较并交换（CAS） LOCK INC ; 原子自增 LOCK DEC ; 原子自减 ; 这些指令前缀LOCK会锁定内存总线，确保操作原子性2.CAS（Compare and Swap）原理
CAS是大多数原子操作的基础：
// CAS操作的伪代码publicclassCAS{// 内存位置V，期望值A，新值BbooleancompareAndSwap(int*V,intA,intB){if(*V==A){// 如果内存值等于期望值*V=B;// 更新为新值returntrue;// 成功}returnfalse;// 失败}}// 实际使用volatileintvalue=0;// 原子地更新value：如果当前是0，则改为1while(true){intcurrent=value;intnext=current+1;if(compareAndSwap(&value,current,next)){break;// 更新成功}// 更新失败（被其他线程修改），重试}3.内存屏障（Memory Barrier）
确保指令执行顺序和内存可见性：
// Java中的内存屏障publicclassMemoryBarrierExample{privatevolatileintflag=0;privateintdata=0;publicvoidwrite(){data=42;// 普通写// StoreStore屏障（volatile写之前）flag=1;// volatile写，包含内存屏障// StoreLoad屏障（volatile写之后）}publicvoidread(){if(flag==1){// volatile读，包含内存屏障// LoadLoad屏障（volatile读之后）// LoadStore屏障（volatile读之后）System.out.println(data);// 保证看到data=42}}}📚 原子操作的类型
1.基本原子操作
importjava.util.concurrent.atomic.*;// 1. 原子整型AtomicIntegeratomicInt=newAtomicInteger(0);atomicInt.incrementAndGet();// i++ 原子版本atomicInt.getAndAdd(5);// 先获取再加atomicInt.compareAndSet(0,1);// CAS操作// 2. 原子长整型AtomicLongatomicLong=newAtomicLong(0L);// 3. 原子布尔型AtomicBooleanatomicBool=newAtomicBoolean(false);// 4. 原子引用AtomicReference<String>atomicRef=newAtomicReference<>("initial");atomicRef.compareAndSet("initial","updated");// 5. 原子数组AtomicIntegerArrayatomicArray=newAtomicIntegerArray(10);atomicArray.getAndAdd(0,5);// 原子更新数组元素2.复合原子操作
// 原子更新器publicclassBankAccount{privatevolatileintbalance;// 自定义原子操作：安全转账publicbooleantransfer(BankAccountto,intamount){while(true){intfromBalance=this.balance;if(fromBalance<amount){returnfalse;// 余额不足}inttoBalance=to.balance;// CAS更新：同时修改两个账户if(AtomicInteger.compareAndSet(this.balance,fromBalance,fromBalance-amount)&&AtomicInteger.compareAndSet(to.balance,toBalance,toBalance+amount)){returntrue;// 转账成功}// 失败重试}}}// 原子字段更新器（无需volatile，性能更好）classCounter{privateintcount;privatestaticfinalAtomicIntegerFieldUpdater<Counter>updater=AtomicIntegerFieldUpdater.newUpdater(Counter.class,"count");publicvoidincrement(){updater.incrementAndGet(this);}}⚡ Java中的原子操作实现
1.Unsafe类 - 底层原子操作
// Unsafe是Java中执行原子操作的底层类publicclassUnsafeExample{privatestaticfinalUnsafeUNSAFE=getUnsafe();privatestaticfinallongVALUE_OFFSET;privatevolatileintvalue;static{try{// 获取字段偏移量VALUE_OFFSET=UNSAFE.objectFieldOffset(UnsafeExample.class.getDeclaredField("value"));}catch(Exceptione){thrownewError(e);}}// 使用Unsafe实现原子操作publicbooleancompareAndSet(intexpect,intupdate){returnUNSAFE.compareAndSwapInt(this,VALUE_OFFSET,expect,update);}publicintgetAndIncrement(){while(true){intcurrent=value;intnext=current+1;if(compareAndSet(current,next)){returncurrent;}}}privatestaticUnsafegetUnsafe(){// 反射获取Unsafe实例（实际使用中不推荐）// ...}}2.Atomic类的实现原理
// AtomicInteger源码分析publicclassAtomicIntegerextendsNumberimplementsjava.io.Serializable{privatestaticfinallongserialVersionUID=6214790243416807050L;// 1. 使用Unsafe进行原子操作privatestaticfinalUnsafeUNSAFE=Unsafe.getUnsafe();privatestaticfinallongvalueOffset;static{try{// 获取value字段的内存偏移量valueOffset=UNSAFE.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));}catch(Exceptionex){thrownewError(ex);}}// 2. volatile保证可见性privatevolatileintvalue;// 3. CAS实现publicfinalbooleancompareAndSet(intexpect,intupdate){returnUNSAFE.compareAndSwapInt(this,valueOffset,expect,update);}// 4. 自增的原子实现publicfinalintincrementAndGet(){returnUNSAFE.getAndAddInt(this,valueOffset,1)+1;}// 5. 乐观锁循环publicfinalintgetAndAdd(intdelta){returnUNSAFE.getAndAddInt(this,valueOffset,delta);}}3.LongAdder - 高并发优化
// LongAdder：分段累加，减少竞争publicclassLongAdderExample{privatefinalLongAdderadder=newLongAdder();publicvoidhighConcurrencyIncrement(){// 在高度竞争环境下性能优于AtomicLongadder.increment();// 内部原理：多个Cell分散竞争// base + cell[0] + cell[1] + ... + cell[n]}publiclongsum(){returnadder.sum();// 返回总和}}// LongAdder vs AtomicLong性能对比// 线程数少时：AtomicLong更快// 线程数多时：LongAdder更快（减少CAS竞争）🔄 原子操作 vs 锁
性能对比：
// 测试代码：对比不同实现的性能publicclassPerformanceTest{privateintcounter=0;privatefinalAtomicIntegeratomicCounter=newAtomicInteger(0);privatefinalReentrantLocklock=newReentrantLock();// 1. 非线程安全（最快的，但可能出错）publicvoidunsafeIncrement(){counter++;}// 2. synchronized锁（较慢）publicsynchronizedvoidsynchronizedIncrement(){counter++;}// 3. ReentrantLock（比synchronized稍快）publicvoidlockIncrement(){lock.lock();try{counter++;}finally{lock.unlock();}}// 4. 原子操作（最快且线程安全）publicvoidatomicIncrement(){atomicCounter.incrementAndGet();}// 5. LongAdder（高并发时最快）privatefinalLongAdderlongAdder=newLongAdder();publicvoidlongAdderIncrement(){longAdder.increment();}}性能测试结果（假设）：
线程数: 1 synchronized: 100 ns/op ReentrantLock: 90 ns/op AtomicInteger: 15 ns/op LongAdder: 20 ns/op 线程数: 10 synchronized: 500 ns/op ReentrantLock: 450 ns/
