前言
C# 13 引入了新的线程同步类型 System.Threading.Lock，它通过作用域管理的方式简化了锁的使用，使代码更加清晰可靠。
本文将全面介绍 System.Threading.Lock 的功能、适用场景，并提供完整的运行示例程序。
1、什么是System.Threading.Lock？
System.Threading.Lock 是一个新的线程同步类型，用于简化对共享资源的访问控制。通过 EnterScope() 方法，可以在特定的作用域内进入临界区，并在作用域结束时自动释放锁。
System.Threading.Lock的优势
自动化管理锁释放： 无需手动调用 Monitor.Exit 或 Dispose。
作用域管理： 锁的生命周期与代码块作用域一致，减少内存泄漏或死锁的风险。
简洁性： 避免手动 try-finally 处理，代码更加清晰。
2、适用场景和完整示例
以下是一些典型使用场景，每个场景都包含完整的代码示例，可以拷贝测试运行。
场景 1 多线程计数器的线程安全操作
多个线程同时递增共享计数器，使用 System.Threading.Lock 确保线程安全。
using System;
using System.Threading;
using System.Threading.Tasks;
namespace CSharp13App
{
class Program
{
private static Lock _lock = new Lock();
private static int _counter = 0;
static async Task Main(string[] args)
{
Console.WriteLine("多线程计数器示例开始...");
// 启动多个并发任务
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => IncrementCounter());
}
// 等待所有任务完成
await Task.WhenAll(tasks);
Console.WriteLine($"计数器最终值: {_counter}");
}
static void IncrementCounter()
{
using (_lock.EnterScope())
{
Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在递增计数器...");
int temp = _counter;
Thread.Sleep(100); // 模拟复杂操作
_counter = temp + 1;
Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 更新后的计数器值: {_counter}");
}
}
}
}
执行结果
场景 2：保护共享队列的线程安全操作
在生产者-消费者模式中，保护队列的读写操作。
using System;
using System.Threading;
using System.Threading.Tasks;
namespace CSharp13App
{
class Program
{
private static Lock _queueLock = new Lock();
private static Queue<int> _queue = new Queue<int>();
static async Task Main(string[] args)
{
Task producer = Task.Run(() => Producer());
Task consumer = Task.Run(() => Consumer());
await Task.WhenAll(producer, consumer);
}
static void Producer()
{
for (int i = 0; i < 10; i++)
{
using (_queueLock.EnterScope())
{
_queue.Enqueue(i);
Console.WriteLine($"生产者添加: {i}");
}
Thread.Sleep(200); // 模拟生产延迟
}
}
static void Consumer()
{
for (int i = 0; i < 10; i++)
{
int item;
using (_queueLock.EnterScope())
{
if (_queue.Count > 0)
{
item = _queue.Dequeue();
Console.WriteLine($"消费者取出: {item}");
}
else
{
Console.WriteLine("队列为空，等待中...");
continue;
}
}
Thread.Sleep(300); // 模拟消费延迟
}
}
}
}
执行结果
场景 3：异步代码中的线程同步
在异步任务中保护共享资源，避免死锁或资源竞争。
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
private static Lock _lock = new Lock();
private static int _sharedResource = 0;
static async Task Main(string[] args)
{
Task[] tasks = new Task[5];
for (int i = 0; i < 5; i++)
{
tasks[i] = PerformAsyncTask(i);
}
await Task.WhenAll(tasks);
Console.WriteLine($"共享资源最终值: {_sharedResource}");
}
static async Task PerformAsyncTask(int taskId)
{
// 在加锁范围内操作共享资源
int temp;
using (_lock.EnterScope())
{
Console.WriteLine($"任务 {taskId} 正在访问共享资源...");
temp = _sharedResource + 1; // 加锁范围内完成操作
}
// 在加锁范围外进行异步操作
await Task.Delay(500); // 模拟异步操作
using (_lock.EnterScope())
{
_sharedResource = temp; // 再次进入锁更新共享资源
Console.WriteLine($"任务 {taskId} 完成，更新共享资源为: {_sharedResource}");
}
}
//static async Task PerformAsyncTask(int taskId)
//{
// using (_lock.EnterScope())
// {
// Console.WriteLine($"任务 {taskId} 正在访问共享资源...");
// int temp = _sharedResource;
// await Task.Delay(500); // 模拟异步操作
// _sharedResource = temp + 1;
// Console.WriteLine($"任务 {taskId} 完成，更新共享资源为: {_sharedResource}");
}
}
}
执行结果 这里有一个错误的写法，会导致异常出现：
这个错误是因为 System.Threading.Lock.Scope 的实例不能跨越 await 或 yield 边界。
原因在于 C# 编译器不允许某些结构（值类型）在 async 方法的 await 关键字之后被持有，因为它们可能在任务的不同时间点被破坏或复制，从而导致未定义行为。
System.Threading.Lock 是一个值类型，当我们使用 using (_lock.EnterScope()) 时，它返回的 Scope 结构无法正确跨越 await 边界。这种限制需要我们重新设计异步操作的锁逻辑。修改之后的执行：
场景 4：复杂计算的线程安全管理
在并发的计算任务中保护计算结果。
using System;
using System.Threading;
using System.Threading.Tasks;
namespace CSharp13App
{
class Program
{
private static Lock _lock = new Lock();
private static int _result = 0;
static async Task Main(string[] args)
{
Console.WriteLine("并发计算示例开始...");
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
int value = i;
tasks[i] = Task.Run(() => PerformCalculation(value));
}
await Task.WhenAll(tasks);
Console.WriteLine($"计算结果: {_result}");
}
static void PerformCalculation(int value)
{
using (_lock.EnterScope())
{
Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 计算: {_result} + {value}");
_result += value;
Thread.Sleep(100); // 模拟计算耗时
}
}
}
}
执行结果
3、为什么选择System.Threading.Lock？
代码可读性： 使用 using 块管理锁的生命周期，减少繁琐的锁释放代码。
线程安全： 确保锁的自动释放，避免死锁或锁泄漏。
适配异步场景： 与异步代码的无缝集成。
降低错误率： 封装复杂的同步操作，开发者无需关注底层实现。
4、总结
System.Threading.Lock 是 C# 13 引入的一项强大功能，提供了简洁、安全、高效的线程同步解决方案。它适用于所有需要保护共享资源的场景，无论是多线程计数器、队列操作，还是异步任务管理。
通过上述示例程序，我们可以清晰地看到 System.Threading.Lock 的实际应用，并快速将其应用到自己的项目中。
你还在手动管理锁吗？是时候尝试 System.Threading.Lock了！
最后
如果你觉得这篇文章对你有帮助，不妨点个赞支持一下！你的支持是我继续分享知识的动力。如果有任何疑问或需要进一步的帮助，欢迎随时留言。
也可以加入微信公众号 [DotNet技术匠] 社区，与其他热爱技术的同行一起交流心得，共同成长！
优秀是一种习惯，欢迎大家留言学习！
作者：dotnet研习社
出处：mp.weixin.qq.com/s/qqPghtEkHRQOaHzALZVEUg
声明：网络内容，仅供学习，尊重版权，侵权速删，歉意致谢！
