C#13新特性使用System.Threading.Lock简化线程同步

程序笔记 2024年12月16日09:03 阅读(213)

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 了！