什么是 Interlocked.Exchange？

Interlocked.Exchange 是 System.Threading.Interlocked 类中的静态方法，用于原子地替换（交换）一个变量的值，并返回该变量的旧值。整个读-改-写过程是不可分割的，在多线程环境中保证线程安全。

• 核心作用：无锁地（lock-free）将变量设置为新值，同时获取旧值。

• 常见重载：

public static int Exchange(ref int location, int value);
public static long Exchange(ref long location, long value);
public static float Exchange(ref float location, float value);
public static double Exchange(ref double location, double value);
public static T Exchange<T>(ref T location, T value) where T : class;  // 引用类型
public static object Exchange(ref object location, object newValue);

• 参数：

  • location：要替换的共享变量（必须ref传递，直接操作内存地址）。

  • value / newValue：要写入的新值。

• 返回值：操作前的旧值。

底层基于 CPU 的原子交换指令（如 x86 的 xchg），性能极高。

为什么使用 Interlocked.Exchange？

普通的 “读取值 + 赋值新值” 是两步非原子操作，多线程下会因竞态条件导致逻辑错误。

• 典型问题：

// 非原子操作：读取旧值和赋值新值之间可能被其他线程打断
private static int _flag = 0;
public static int UnsafeReplace(int newValue)
{
    int oldValue = _flag; // 步骤1：读取旧值
    _flag = newValue;     // 步骤2：赋值新值
    return oldValue;      // 返回旧值
}

若两个线程同时执行上述代码，可能出现 “线程 A 读取旧值后，线程 B 已修改值，线程 A 最终返回的旧值与实际赋值前的旧值不一致” 的问题。Interlocked.Exchange 将 “读取旧值 + 设置新值” 合并为不可中断的原子操作，从底层杜绝竞态条件，且无需阻塞线程（无锁）。

Interlocked.Exchange 的核心优势与适用场景

在多线程编程中，Interlocked.Exchange 提供了极具价值的保障，其核心优势体现在以下几个方面：

• 原子性：读取旧值与写入新值作为一个不可分割的操作完成，中间状态对其它线程不可见。
• 高性能：采用无锁机制，避免了传统锁机制带来的上下文切换开销，执行效率极高。
• 可见性：确保写入操作对所有线程立即可见，无需额外的同步手段即可获取最新数据。
• 有序性：通过内存屏障机制，保证写入操作之前的指令不会被重排序到写入操作之后。
• 无锁特性：不会阻塞线程，避免了死锁风险，适合高并发场景。

基于上述特性，该函数主要适用于以下典型场景：

• 线程安全的状态切换：例如在启用或禁用某个功能标志时，确保状态变更的原子性。
• 实现懒加载单例：通过原子替换 null 为实例，防止多线程下重复创建对象。
• 原子更新引用：如缓存对象的替换，确保旧引用被安全回收且新引用立即生效。
• 构建同步原语：用于实现 SpinLock 或自定义的高级同步机制。

核心原理：CPU 级原子指令

Interlocked.Exchange 的原子性并非由软件模拟，而是直接依赖 CPU 硬件指令实现：

• x86 架构：使用 LOCK 指令（LOCK XCHG 前缀独占内存总线，阻止其他 CPU 核心修改该内存地址）。
• ARM 架构：使用 LDXR/STXR（交换指令）或 LDREX/STREX（加载 - 存储独占）指令。

同时，该操作会触发全内存屏障（Full Memory fence），其作用包括：

• 保证操作前后的内存读写不会被 CPU 重排序，维持指令执行顺序。
• 确保所有线程能立即看到变量的最新值，有效避免 CPU 缓存导致的 “脏读” 问题。

基础使用示例

最简单的原子替换（返回原始值）

private static int _counter = 0;

public static void TestExchange()
{
    // 目标：将_counter从0替换为100，获取原始值
    int newValue = 100;
    int originalValue = Interlocked.Exchange(ref _counter, newValue);
    
    Console.WriteLine($"原始值：{originalValue}，新值：{_counter}");
    // 输出：原始值：0，新值：100

    // 再次替换：将_counter从100替换为200
    originalValue = Interlocked.Exchange(ref _counter, 200);
    Console.WriteLine($"原始值：{originalValue}，新值：{_counter}");
    // 输出：原始值：100，新值：200
}

线程安全标志位

private int _isProcessing = 0; // 0=未处理, 1=处理中

public bool StartProcessing()
{
    // 如果当前为0（未处理），则设为1（处理中）并返回true
    return Interlocked.Exchange(ref _isProcessing, 1) == 0;
}

public void EndProcessing()
{
    // 重置为未处理状态
    Interlocked.Exchange(ref _isProcessing, 0);
}

一次性资源释放（防止重复 Dispose）

private IDisposable _resource;

public void Dispose()
{
    var res = Interlocked.Exchange(ref _resource, null);
    res.Dispose();
}

无锁发布对象（Safe Publication）

private object _instance;

public object GetOrCreate()
{
    if (_instance != null)
        return _instance;

    var newObj = new object();
    Interlocked.Exchange(ref _instance, newObj);
    return newObj;
}

多线程下的原子状态切换

高级应用场景

单例模式（结合 Exchange 实现懒加载）

用 Exchange 替代 lock 实现高性能单例

public sealed class LazySingleton
{
    // 单例实例（引用类型）
    private static LazySingleton _instance;
    // 初始化标记：0=未初始化，1=已初始化
    private static int _initialized = 0;

    private LazySingleton() { } // 私有构造

    public static LazySingleton Instance
    {
        get
        {
            // 原子替换：将_initialized从0改为1，仅第一次调用返回0
            if (Interlocked.Exchange(ref _initialized, 1) == 0)
            {
                _instance = new LazySingleton(); // 仅执行一次初始化
            }
            return _instance!;
        }
    }
}

取消令牌的原子重置

用 Exchange 原子替换 CancellationTokenSource，实现 “取消后重置” 的线程安全逻辑：

private static CancellationTokenSource _cts = new CancellationTokenSource();

/// 

/// 原子重置取消令牌（取消旧令牌，创建新令牌）
/// 
public static CancellationToken ResetCts()
{
    // 1. 原子替换旧的Cts为新实例，获取旧实例
    CancellationTokenSource oldCts = Interlocked.Exchange(ref _cts, new CancellationTokenSource());
    // 2. 取消旧令牌（避免旧任务继续执行）
    if (oldCts != null)
    {
        oldCts.Cancel();
        oldCts.Dispose();
    }
    // 3. 返回新令牌
    return _cts.Token;
}

引用类型：原子替换对象引用（最常用）

private ExpensiveObject _cache = null;

public ExpensiveObject GetOrCreate()
{
    // 如果为 null，原子替换为新实例
    var newInstance = new ExpensiveObject();
    var oldInstance = Interlocked.Exchange(ref _cache, newInstance);

    return oldInstance  newInstance;  // 如果旧值为 null，返回新实例
}

与 Interlocked.CompareExchange 的关系

对比示例

// Exchange：不管原来是什么，都换
Interlocked.Exchange(ref state, 1);

// CompareExchange：只有 state == 0 才换
Interlocked.CompareExchange(ref state, 1, 0);

总结

Interlocked.Exchange 是 .NET 中最简单、最快、最安全的“原子替换”操作， 它是实现一次性执行、无锁状态切换、安全对象发布的基石。

// 状态枚举：0=未初始化，1=初始化中，2=已初始化
private static int _initState = 0;
// 模拟初始化成本高的对象
private static ExpensiveObject _expensiveObj;

/// 

/// 线程安全的一次性初始化
/// 
public static ExpensiveObject GetExpensiveObject()
{
    // 1. 原子替换：将状态从0（未初始化）改为1（初始化中）
    int originalState = Interlocked.Exchange(ref _initState, 1);
    
    // 2. 只有原始状态是0的线程，执行初始化
    if (originalState == 0)
    {
        Console.WriteLine($"线程{Thread.CurrentThread.ManagedThreadId}：执行初始化...");
        _expensiveObj = new ExpensiveObject(); // 耗时初始化
        // 3. 初始化完成，将状态改为2（已初始化）
        Interlocked.Exchange(ref _initState, 2);
    }
    else
    {
        // 其他线程等待初始化完成
        while (_initState != 2)
        {
            Thread.SpinWait(10); // 自旋等待（轻量级）
        }
        Console.WriteLine($"线程{Thread.CurrentThread.ManagedThreadId}：初始化已完成，直接返回对象");
    }
    
    return _expensiveObj!;
}

// 测试：10个线程同时调用，仅1个线程执行初始化
var tasks = Enumerable.Range(0, 10)
    .Select(_ => Task.Run(() => GetExpensiveObject()))
    .ToList();
Task.WaitAll(tasks.ToArray());

// 模拟创建成本高的对象
public class ExpensiveObject
{
    public ExpensiveObject()
    {
        Thread.Sleep(1000); // 模拟1秒耗时初始化
    }
}

线程3：执行初始化...
线程4：初始化已完成，直接返回对象
线程5：初始化已完成，直接返回对象
...（其余线程均输出此内容）