前言
在当今高并发、多核处理器普及的时代，多线程编程已成为现代软件开发不可或缺的一部分。然而，多线程带来的最大挑战之一便是共享数据的线程安全问题。当多个线程同时访问和修改共享变量时，极易引发"竞态条件"（Race Condition），导致程序行为不可预测甚至崩溃。
传统的解决方案依赖于lock、Monitor等锁机制，虽然能保证同步，但往往带来性能开销和死锁风险。为此，.NET平台提供了一个轻量级、高性能的替代方案——System.Threading.Interlocked类。它利用底层CPU的原子指令，实现了无需锁的线程安全操作，是实现高效并发编程的重要工具。
本文将系统性地介绍Interlocked类的核心原理、常用方法、实际应用场景，并通过代码示例和性能对比，帮助开发深入理解其优势与适用边界。
正文
什么是Interlocked？
Interlocked是.NET框架中位于System.Threading命名空间下的一个静态类，专门用于执行原子操作（Atomic Operations）。所谓原子操作，是指该操作在执行过程中不会被其他线程中断，要么完全执行，要么完全不执行，不存在中间状态。
在多线程环境中，多个线程同时对共享变量进行读写操作时，若不加同步，可能导致数据不一致。例如，两个线程同时对一个整型变量执行++操作，最终结果可能只加了1，而非预期的2。Interlocked通过调用底层CPU指令（如x86架构的LOCK前缀指令），确保诸如递增、递减、交换等操作的原子性，从而避免竞态条件。
为什么选择Interlocked？
相比于传统的锁机制（如lock关键字），Interlocked具有显著优势：
1、原子性操作
所有操作均不可中断，从根本上避免了竞态条件。
2、轻量级高性能
不涉及线程阻塞、上下文切换和内核对象的创建，性能远高于lock。
3、无锁设计
避免了死锁、活锁等问题，简化了并发逻辑。
4、简洁易用
API设计直观，代码清晰，易于维护。
Interlocked的主要方法
Interlocked类提供了多种静态方法，支持对整数、引用类型和指针的原子操作：
-
Increment(ref int location)：原子递增 -
Decrement(ref int location)：原子递减 -
Add(ref int location, int value)：原子加法 -
Exchange(ref T location, T value)：原子交换 -
CompareExchange(ref T location, T value, T comparand)：比较并交换（CAS）
这些方法是构建线程安全数据结构的基础。
实际应用场景
线程安全计数器
计数器是最常见的应用场景。以下示例创建10个线程，每个线程对共享计数器递增1000次，使用Interlocked.Increment确保结果准确：
namespace AppInterlocked
{
internal class Program
{
// 共享计数器变量
private static int counter = 0;
static void Main()
{
// 创建10个线程
Thread[] threads = new Thread[10];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(() =>
{
// 每个线程递增计数器1000次
for (int j = 0; j < 1000; j++)
{
Interlocked.Increment(ref counter);
// 如果使用 counter++ 则可能导致计数不准确
}
});
threads[i].Start();
}
// 等待所有线程完成
foreach (var t in threads) t.Join();
Console.WriteLine($"最终计数器值: {counter}");
}
}
}
使用Interlocked.Add进行原子累加
Interlocked.Add允许原子地添加任意值：
namespace AppInterlocked
{
internal class Program
{
private static int total = 0;
static void Main()
{
// 使用并行任务
Parallel.For(0, 100, i =>
{
// 每个任务添加不同的值
Interlocked.Add(ref total, i);
});
Console.WriteLine($"累加结果: {total}");
}
}
}
实现线程安全的标志位（布尔值）
虽然Interlocked不直接支持bool，但可用整数模拟：
namespace AppInterlocked
{
internal class Program
{
private static int total = 0;
// 使用0表示false，1表示true
private static int isRunning = 0;
static void StartProcess()
{
// 尝试将isRunning从0设为1，如果成功（返回值是0）则执行
if (Interlocked.CompareExchange(ref isRunning, 1, 0) == 0)
{
try
{
Console.WriteLine("进程开始执行...");
// 执行需要互斥的操作
Task.Delay(1000).Wait(); // 模拟工作
Console.WriteLine("进程执行完成");
}
finally
{
// 完成后重置标志位
Interlocked.Exchange(ref isRunning, 0);
}
}
else
{
Console.WriteLine("进程已在运行中，无法启动");
}
}
static void Main()
{
Task[] tasks = new Task[5];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Task.Run(() => StartProcess());
}
Task.WaitAll(tasks);
}
}
}
使用Exchange进行原子交换
Interlocked.Exchange用于原子替换值并返回旧值：
namespace AppInterlocked
{
internal class Program
{
private static string sharedResource = "初始值";
static void UpdateResource(string newValue)
{
// 原子地用新值替换旧值，并返回旧值
string oldValue = Interlocked.Exchange(ref sharedResource, newValue);
Console.WriteLine($"资源从 '{oldValue}' 更新为 '{newValue}'");
}
static void Main()
{
Thread t1 = new Thread(() => UpdateResource("线程1的值"));
Thread t2 = new Thread(() => UpdateResource("线程2的值"));
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Console.WriteLine($"最终资源值: {sharedResource}");
}
}
}
使用CompareExchange实现复杂的条件更新
CompareExchange是实现无锁算法的核心，常用于实现自旋锁、无锁栈等：
namespace AppInterlocked
{
internal class Program
{
private static int counter = 0;
static void ConditionalIncrement(int threshold)
{
int current, newValue;
do
{
// 读取当前值
current = counter;
// 如果当前值已经达到或超过阈值，则不更新
if (current >= threshold)
{
Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId}: 值 {current} 已达到阈值 {threshold}，不再增加");
return;
}
// 计算新值
newValue = current + 1;
} while (Interlocked.CompareExchange(ref counter, newValue, current) != current);
Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId}: 将计数器从 {current} 增加到 {newValue}");
}
static void Main()
{
const int threshold = 10;
Task[] tasks = new Task[20];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Task.Run(() => ConditionalIncrement(threshold));
}
Task.WaitAll(tasks);
Console.WriteLine($"最终计数器值: {counter}");
}
}
}
性能对比：Interlocked vs. lock
以下代码展示了Interlocked.Increment与lock在百万级操作下的性能差异：
using System.Diagnostics;
namespace AppInterlocked
{
internal class Program
{
private static int counterInterlocked = 0;
private static int counterLock = 0;
private static object lockObj = new object();
static void Main()
{
const int operationsCount = 10000000;
const int threadsCount = 8;
// 测试Interlocked
Stopwatch swInterlocked = Stopwatch.StartNew();
Parallel.For(0, threadsCount, _ =>
{
for (int i = 0; i < operationsCount / threadsCount; i++)
{
Interlocked.Increment(ref counterInterlocked);
}
});
swInterlocked.Stop();
// 测试lock
Stopwatch swLock = Stopwatch.StartNew();
Parallel.For(0, threadsCount, _ =>
{
for (int i = 0; i < operationsCount / threadsCount; i++)
{
lock (lockObj)
{
counterLock++;
}
}
});
swLock.Stop();
Console.WriteLine($"Interlocked 计数器: {counterInterlocked}, 耗时: {swInterlocked.ElapsedMilliseconds}ms");
Console.WriteLine($"Lock 计数器: {counterLock}, 耗时: {swLock.ElapsedMilliseconds}ms");
Console.WriteLine($"性能差异比: {(double)swLock.ElapsedMilliseconds / swInterlocked.ElapsedMilliseconds:F2}x");
}
}
}
通常，Interlocked的性能是lock的数倍甚至数十倍。
Interlocked的局限性
尽管强大，Interlocked也有其局限：
1、仅支持简单原子操作：不适合复杂逻辑或多变量同步。
2、数据类型有限：主要支持整型、引用类型。
3、不支持bool：需用int模拟。
4、不适合长时间操作：应仅用于快速操作。
何时使用Interlocked？
推荐在以下场景使用：
-
线程安全计数器
-
标志位设置/清除
-
简单共享变量更新
-
高性能、低延迟应用
-
需避免死锁的场景
对于复杂同步，建议使用lock、ReaderWriterLockSlim或Concurrent集合。
总结
Interlocked类是.NET多线程编程中不可或缺的工具。它通过底层原子指令，实现了无锁、高性能的线程同步，特别适用于计数器、标志位等简单共享状态的管理。相较于传统锁机制，Interlocked在性能和可靠性上具有明显优势，是构建高效并发应用的基石。
虽然其功能相对有限，但在合适的场景下使用Interlocked，可以显著提升程序性能，减少资源争用，避免死锁。作为C#开发者，掌握Interlocked的使用，是迈向高级并发编程的重要一步。在未来的高性能系统开发中，合理运用无锁编程思想，将使你的代码更加简洁、高效且健壮。
关键词
C#线程安全操作、Interlocked使用教程、.NET多线程编程、无锁线程同步、原子操作、线程安全计数器、CompareExchange实例、多线程性能优化
最后
如果你觉得这篇文章对你有帮助，不妨点个赞支持一下！你的支持是我继续分享知识的动力。如果有任何疑问或需要进一步的帮助，欢迎随时留言。
也可以加入微信公众号 [DotNet技术匠] 社区，与其他热爱技术的同行一起交流心得，共同成长！
优秀是一种习惯，欢迎大家留言学习！
作者：技术老小子
出处：mp.weixin.qq.com/s/ZAMtBFUjfFUjt_AfgyleUg
声明：网络内容，仅供学习，尊重版权，侵权速删，歉意致谢！
