什么是 Interlocked.CompareExchange？

Interlocked.CompareExchange 是 .NET 中 System.Threading.Interlocked 类的最核心原子操作方法。它执行比较并交换（Compare-And-Swap，简称 CAS） 操作：在多线程环境下，安全地将变量的值与预期值比较，如果相等则替换为新值，整个过程原子不可中断。

关键特性

• 原子性：整个操作在CPU级别是原子的，不会被线程调度打断

• 无锁操作：无需使用锁即可实现线程安全

• 内存屏障：隐含完整内存屏障（full fence），确保操作前后内存访问顺序

返回值重要性：返回值是判断操作是否成功的关键

• 核心签名（常见重载）：

public static int CompareExchange(ref int location, int value, int comparand);
public static long CompareExchange(ref long location, long value, long comparand);
public static T CompareExchange<T>(ref T location, T value, T comparand) where T : class;
public static float CompareExchange(ref float location, float value, float comparand);
public static double CompareExchange(ref double location, double value, double comparand);

• 参数解释：

  • location：要操作的共享变量（必须用 ref 传递）。

  • value：如果比较成功，要写入的新值。

  • comparand：预期旧值（用于比较）。

  • 返回值：操作前 location 的实际值（无论成功与否都返回旧值）。

CAS 是现代无锁（lock-free）并发编程的基础，许多高级结构（如 ConcurrentDictionary、SpinLock）内部都依赖它。

为什么使用 Interlocked.CompareExchange？

在多线程中，直接读取-修改-写入（如 if (count == 0) count = 1;）会产生竞争条件：多个线程可能同时读取相同值，导致覆盖更新。

原子操作的核心价值

在多线程编程中，传统锁机制存在显著缺陷。lock 开销极大，涉及互斥锁的获取与释放以及频繁的上下文切换，这种高昂的性能成本使其完全不适合高频且轻量的操作场景。相比之下，CAS 展现出独特的优势体系。

首先，它实现了真正的无锁（Lock-Free）机制。由于不阻塞线程，在高并发环境下能够保持极高的性能表现。其次，它采用乐观并发策略，假设冲突发生的概率极低，因此先尝试执行操作，若发现失败则通过自旋方式重试，从而避免了传统锁的等待开销。最后，其原子性由硬件级指令（x86 的 cmpxchg 指令）直接保证，确保了数据的一致性。

典型应用场景包括实现线程安全的单例模式，特别是双检查锁机制；构建自定义的无锁队列或栈结构；以及原子更新复杂状态，例如同时处理标志位与计数器的变更。此外，它还可用于实现自定义同步原语，如 SpinLock 和 SemaphoreSlim 的内部实现。

传统的 “比较 + 赋值” 操作在逻辑上分为两步，属于非原子操作。在多线程环境下，这极易因竞态条件导致逻辑错误。

// 非原子操作：多线程下可能同时通过if判断，导致赋值错误
private static int _value = 0;
public static void UnsafeUpdate(int oldVal, int newVal)
{
    if (_value == oldVal) // 步骤1：读取并比较
    {
        _value = newVal;  // 步骤2：赋值
    }
}

什么时候该用 CompareExchange？

当需要保证多个步骤的原子性，且希望避免锁带来的性能损耗时，应优先考虑 CompareExchange。它适用于那些冲突概率较低、重试成本低于锁开销的场景。

如何使用 Interlocked.CompareExchange？

最简单的 CAS 操作（判断是否交换成功）

通过

private static int _counter = 0;

public static void TestCas()
{
    // 目标：如果_counter是0，就改为100
    int expected = 0;    // 预期值
    int newValue = 100;  // 新值
    
    // 执行CAS操作
    int original = Interlocked.CompareExchange(ref _counter, newValue, expected);
    
    // 判断是否交换成功（原始值 == 预期值 → 成功）
    if (original == expected)
    {
        Console.WriteLine($"交换成功！原始值：{original}，新值：{_counter}");
    }
    else
    {
        Console.WriteLine($"交换失败！原始值：{original}，当前值：{_counter}");
    }
}

原子条件更新

在

private int _status = 0;  // 0: 未初始化, 1: 初始化中, 2: 已完成

public void Initialize()
{
    if (Interlocked.CompareExchange(ref _status, 1, 0) == 0)
    {
        // 只有第一个线程进入这里
        try
        {
            // 执行初始化逻辑
            DoInitialize();
        }
        finally
        {
            // 标记完成（原子操作，无需 CAS）
            Interlocked.Exchange(ref _status, 2);
        }
    }
    else
    {
        // 其他线程等待完成
        while (_status != 2) Thread.SpinWait(10);
    }
}

实现自旋锁

利用

public class SpinLock
{
    private int _lock = 0; // 0=未锁定, 1=已锁定
    
    public void Enter()
    {
        while (Interlocked.CompareExchange(ref _lock, 1, 0) != 0)
        {
            // 等待 - 可以使用Thread.SpinWait优化
            Thread.SpinWait(100);
        }
    }
    
    public void Exit()
    {
        Interlocked.Exchange(ref _lock, 0);
    }
}

经典场景：无锁计数器（循环 CAS）

在

private static int _casCounter = 0;

/// 

/// 无锁原子递增（替代Interlocked.Increment）
/// 
public static int IncrementCounter()
{
    int current;   // 当前值
    int newValue;  // 新值
    do
    {
        // 1. 原子读取当前值（Interlocked保证可见性）
        current = _casCounter;
        // 2. 计算新值（仅本地计算，无竞态）
        newValue = current + 1;
        // 3. CAS操作：若当前值未被修改，就更新为新值
        // 返回值≠current → 被其他线程修改，重试
    } while (Interlocked.CompareExchange(ref _casCounter, newValue, current) != current);
    
    return newValue; // 返回递增后的值
}

// 测试：1000个线程各调用1次，最终结果必为1000
var tasks = Enumerable.Range(0, 1000)
    .Select(_ => Task.Run(IncrementCounter))
    .ToList();
Task.WaitAll(tasks.ToArray());
Console.WriteLine($"最终计数器值：{_casCounter}"); // 输出：1000

高级应用场景

泛型版本：懒加载单例（双检查锁模式）

在 .NET 中需加 Lazy 更安全：

无锁状态机（原子状态转换）

控制对象状态的原子转换（如从 Idle→Running ，避免状态混乱）：

自旋实现原子加法（模拟 Interlocked.Add）

• 解释：循环直到 CAS 成功（自旋），实现无锁递增

对象引用替换（线程安全赋值）

Interlocked.CompareExchange 的内部实现

• 硬件支持：

  • x86/x64：LOCK CMPXCHG 指令，总线锁保证原子性。

  • ARM：LDREX/STREX 指令对（Load-Exclusive/Store-Exclusive），失败重试。

同时，该操作会触发全内存屏障（Full Memory Barrier）：

• 保证操作前后的内存读写不会被 CPU 重排序；

• 确保所有线程能立即看到变量的最新值（避免 CPU 缓存导致的 “脏读”）。

• .NET 实现（CoreCLR 简化伪码）：

注意事项与最佳实践

• 自旋循环：总是用 do-while 包装 CAS，形成“乐观循环”。

• ABA 问题：

  • 线程 1 读取值为A，准备 CAS 为C；线程 2 将A改为B，又改回A；线程 1 的 CAS 会成功，但中间状态已变化，可能导致逻辑错误

  • 解决方法：版本号 + 引用 CAS。

• 内存可见性：Interlocked 操作自带全内存屏障（full fence），无需额外 volatile。

• 避免过度使用：简单计数用 Interlocked.Increment；集合用 Concurrent 类。

• 替代方案：

  • 高层：ConcurrentDictionary、BlockingCollection。

  • 现代：System.Threading.Channels（生产者-消费者）。

  • .NET 8+：考虑 System.Threading.Lock（C# 12 新特性，更简洁）。

ABA 问题

什么是 ABA 问题？

ABA 问题 是无锁（lock-free）编程中使用 Compare-And-Swap (CAS) 操作时的一种经典隐患。

场景描述：

• 线程 A 读取共享变量值：A
• 线程 B 先将值改为 B，然后又改回 A
• 线程 A 执行 CAS：期望值是 A，当前值也是 A → CAS 成功！
• 但实际上值已经被其他线程修改过，语义已经改变，线程 A 却误以为“一切未变”。

这会导致逻辑错误，尤其在无锁栈、队列等数据结构中，可能造成节点丢失、循环引用或内存泄漏。

解决方案：版本号 + 引用 CAS

1. 定义「版本化状态对象」

sealed class VersionedValue
{
    public readonly int Value;
    public readonly int Version;

    public VersionedValue(int value, int version)
    {
        Value = value;
        Version = version;
    }

    public override string ToString()
        => $"Value={Value}, Version={Version}";
}

关键点：

• 不可变（readonly）
• 每次修改 → 新对象
• CAS 比较的是 对象引用

2. 运行示例

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static VersionedValue state = new VersionedValue(1, 0);

    static void Main()
    {
        var t1 = Task.Run(Thread1);
        var t2 = Task.Run(Thread2);

        Task.WaitAll(t1, t2);

        Console.WriteLine($"Final state: {state}");
    }

    static void Thread1()
    {
        var old = state; // 读 A(v0)
        Console.WriteLine($"T1 read: {old}");

        Thread.Sleep(200);

        var newState = new VersionedValue(3, old.Version + 1);

        var result = Interlocked.CompareExchange(
            ref state,
            newState,
            old
        );

        if (result == old)
        {
            Console.WriteLine("T1 CAS succeeded");
        }
        else
        {
            Console.WriteLine($"T1 CAS failed, current = {result}");
        }
    }

    static void Thread2()
    {
        Thread.Sleep(50);

        // A → B
        state = new VersionedValue(2, state.Version + 1);
        // B → A
        state = new VersionedValue(1, state.Version + 1);

        Console.WriteLine($"T2 changed state twice: {state}");
    }
}

3. 典型输出

T1 read: Value=1, Version=0
T2 changed state twice: Value=1, Version=2
T1 CAS failed, current = Value=1, Version=2
Final state: Value=1, Version=2

核心结果：

• 值还是 1
• 版本已经变了
• CAS 失败
• ABA 被成功识别

为什么这个方案一定能防 ABA？

CAS 比较的是“对象引用”，而不是值

即使：

Value: 1 → 2 → 1

但：

Reference: A → B → C

A ≠ C

CAS 不可能误判成功

黄金组合

.NET 官方并发集合、Immutable 系列，都是这个思想

什么时候该用这一套？

适合：

• 自定义状态机
• CAS + 状态切换
• 无锁缓存
• 高频并发更新

不适合：

• 普通计数
• 简单标志位
• 低并发业务

总结

Interlocked.CompareExchange 是 .NET 无锁并发的“原子开关” 用它可以：

• 不加锁
• 不阻塞
• 在竞争中安全修改状态

public sealed class Singleton
{
    private static Singleton _instance = null;

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                var temp = new Singleton();
                Interlocked.CompareExchange(ref _instance, temp, null);
            }
            return _instance;
        }
    }
}

private static Lazy _instance = new Lazy(() => new Singleton());
public static Singleton Instance => _instance.Value;

// 定义状态枚举
public enum TaskState { Idle, Running, Completed, Failed }

public class TaskStateMachine
{
    private TaskState _state = TaskState.Idle;

    /// 

    /// 原子转换：Idle → Running（仅当状态为Idle时成功）
    /// 
    public bool TryStart()
    {
        TaskState original = Interlocked.CompareExchange(
            ref _state, 
            TaskState.Running,  // 新值
            TaskState.Idle      // 预期值
        );
        return original == TaskState.Idle; // 原始值=预期值 → 转换成功
    }

    /// 

    /// 原子转换：Running → Completed
    /// 
    public bool TryComplete()
    {
        TaskState original = Interlocked.CompareExchange(
            ref _state, 
            TaskState.Completed, 
            TaskState.Running
        );
        return original == TaskState.Running;
    }
}

// 使用
var stateMachine = new TaskStateMachine();
Console.WriteLine(stateMachine.TryStart());    // true（状态变为Running）
Console.WriteLine(stateMachine.TryStart());    // false（已不是Idle）
Console.WriteLine(stateMachine.TryComplete()); // true（状态变为Completed）

private int _counter = 0;

public int Increment()
{
    int oldValue, newValue;
    do
    {
        oldValue = _counter;
        newValue = oldValue + 1;
    } while (Interlocked.CompareExchange(ref _counter, newValue, oldValue) != oldValue);
    return newValue;
}

private List<int> _cache = null;

public void UpdateCache(List<int> newCache)
{
    Interlocked.CompareExchange(ref _cache, newCache, _cache);  // 仅当未被其他线程修改时更新
}

public static int CompareExchange(ref int location, int value, int comparand)
{
    // 内联为平台特定原子指令
    fixed (int* ptr = &location)
    {
        return InterlockedCompareExchange(ptr, value, comparand);
    }
}