查不到备案的网站,wordpress设置会员时效,西安 网站 公司,市场营销与网络营销总目录 前言
在 C# 多线程编程中#xff0c;lock 关键字是一种非常重要的同步机制#xff0c;用于确保同一时间只有一个线程可以访问特定的代码块#xff0c;从而避免多个线程同时操作共享资源时可能出现的数据竞争和不一致问题。以下是关于 lock 关键字的详细使用介绍。 一…总目录 前言
在 C# 多线程编程中lock 关键字是一种非常重要的同步机制用于确保同一时间只有一个线程可以访问特定的代码块从而避免多个线程同时操作共享资源时可能出现的数据竞争和不一致问题。以下是关于 lock 关键字的详细使用介绍。 一、基本概念
lock 关键字提供了一种简单的方法来实现互斥锁mutex它通过锁定一个对象来保护临界区内的代码。当一个线程进入被 lock 保护的代码块时其他尝试进入同一代码块的线程将被阻塞直到第一个线程完成并释放锁。
lock 关键字的基本语法如下
lock (object)
{// 要保护的代码块/临界区代码
}其中object 是一个引用类型的对象通常是一个私有的静态或实例成员变量通常称为 “锁对象”。lock 语句会获取这个锁对象的独占锁当一个线程进入 lock 块时它会尝试获取锁对象的锁。如果锁对象当前没有被其他线程持有该线程会获取锁并执行 lock 块内的代码如果锁对象已经被其他线程持有当前线程会被阻塞直到持有锁的线程退出 lock 块并释放锁。
为了确保线程安全所有需要同步访问的代码都应该使用同一个锁对象。
二、使用
1. 基本使用
下面是一个简单的示例展示了如何使用 lock 关键字来保护共享资源
using System;
using System.Threading;class Program
{private static int sharedCounter 0;private static readonly object lockObject new object();static void Main(){// 创建两个线程Thread thread1 new Thread(IncrementCounter);Thread thread2 new Thread(IncrementCounter);// 启动线程thread1.Start();thread2.Start();// 等待两个线程执行完毕thread1.Join();thread2.Join();// 输出最终的计数器值Console.WriteLine($Final counter value: {sharedCounter});}static void IncrementCounter(){for (int i 0; i 100000; i){// 使用 lock 关键字保护共享资源lock (lockObject){sharedCounter;}}}
}在这个示例中sharedCounter 是一个共享资源多个线程可能同时对其进行递增操作。为了避免数据竞争我们使用 lock 关键字来保护 sharedCounter 的递增操作。lockObject 是一个用于锁定的对象两个线程在执行 sharedCounter 之前都会尝试获取 lockObject 的锁只有获取到锁的线程才能执行递增操作从而确保同一时间只有一个线程可以修改 sharedCounter 的值。
2. 静态 vs 实例锁
根据锁对象是静态成员还是实例成员lock 可以保护类级别的资源或对象级别的资源
静态锁用于保护类的所有实例之间的共享资源。实例锁用于保护单个对象的状态。
示例静态锁 vs 实例锁
public class Singleton
{private static readonly object _staticLock new object();private readonly object _instanceLock new object();public void StaticMethod(){lock (_staticLock){// Shared resource access}}public void InstanceMethod(){lock (_instanceLock){// Object-specific resource access}}
}三、 注意事项
1. 锁的粒度
合理控制锁的粒度对于性能至关重要
粗粒度锁锁定整个方法或较大的代码段。虽然简单易用但可能导致不必要的阻塞影响吞吐量。细粒度锁只锁定必要的最小代码片段。这样可以减少等待时间提高并发性但也增加了复杂性和潜在的死锁风险。
最佳实践
要合理控制锁的粒度即 lock 块内的代码量。如果锁的粒度过大会导致其他线程等待的时间过长降低程序的性能如果锁的粒度过小可能无法有效保护共享资源仍然会出现数据竞争问题。尽量缩小锁的作用范围只锁定那些真正需要同步的代码行。此外避免在锁内部执行长时间运行的操作如I/O访问或复杂的计算。
2. 避免死锁
死锁是指两个或多个线程相互等待对方释放锁从而导致所有线程都无法继续执行的情况。为了避免死锁应该尽量减少锁的嵌套确保线程按照相同的顺序获取锁。
关于死锁详情下文会有详细介绍。
3. 锁对象的选择
专用锁对象确保所有需要同步的代码使用相同的锁对象。通常建议使用一个专用的、私有的引用类型对象作为锁对象如上面示例中的 lockObject。这样可以避免不同的代码块或类之间意外地共享同一个锁对象从而减少死锁和其他同步问题的发生。避免使用 this在实例方法中不建议使用 this 作为锁对象因为其他代码可能会无意中锁定同一个对象导致意想不到的结果。例如
class MyClass
{private int counter 0;public void Increment(){// 不推荐使用 this 作为锁对象lock (this){counter;}}
}避免使用字符串也不建议使用字符串作为锁对象因为字符串具有字符串驻留机制可能会导致不同的代码块使用相同的字符串作为锁对象从而引发同步问题。
四、死锁
死锁指的是两个或多个线程相互等待对方释放锁从而导致所有线程都无法继续执行的情况
1. 死锁示例
以下是一个用 C# 编写的会发生死锁的案例这个案例模拟了两个线程互相等待对方释放锁的情况从而导致死锁。
using System;
using System.Threading;class DeadlockExample
{// 定义两个锁对象private static readonly object lock1 new object();private static readonly object lock2 new object();static void Main(){// 创建第一个线程Thread thread1 new Thread(Function1);// 创建第二个线程Thread thread2 new Thread(Function2);// 启动第一个线程thread1.Start();// 稍微延迟一下让 thread1 有机会先获取 lock1Thread.Sleep(100);// 启动第二个线程thread2.Start();// 等待两个线程执行完成thread1.Join();thread2.Join();Console.WriteLine(程序执行结束);}static void Function1(){// 线程 1 先获取 lock1lock (lock1){Console.WriteLine(线程 1 已获取 lock1正在尝试获取 lock2...);// 稍微延迟一下增加死锁发生的概率Thread.Sleep(200);// 线程 1 尝试获取 lock2lock (lock2){Console.WriteLine(线程 1 已获取 lock2);}}}static void Function2(){// 线程 2 先获取 lock2lock (lock2){Console.WriteLine(线程 2 已获取 lock2正在尝试获取 lock1...);// 稍微延迟一下增加死锁发生的概率Thread.Sleep(200);// 线程 2 尝试获取 lock1lock (lock1){Console.WriteLine(线程 2 已获取 lock1);}}}
}代码解释
锁对象的定义
lock1 和 lock2 是两个静态的、只读的 object 类型对象作为锁使用。
线程的创建和启动
thread1 执行 Function1 方法thread2 执行 Function2 方法。在启动 thread2 之前让主线程休眠 100 毫秒目的是让 thread1 有机会先获取 lock1。
Function1 方法
线程 1 首先获取 lock1然后输出提示信息表示正在尝试获取 lock2。线程 1 休眠 200 毫秒增加死锁发生的概率。线程 1 尝试获取 lock2。
Function2 方法
线程 2 首先获取 lock2然后输出提示信息表示正在尝试获取 lock1。线程 2 休眠 200 毫秒增加死锁发生的概率。线程 2 尝试获取 lock1。
死锁的产生过程
线程 1 先获取了 lock1然后尝试获取 lock2。线程 2 先获取了 lock2然后尝试获取 lock1。此时线程 1 持有 lock1 并等待 lock2而线程 2 持有 lock2 并等待 lock1两个线程互相等待对方释放锁从而导致死锁程序将无法继续执行下去。
运行这个程序时你会看到控制台输出类似以下的内容
线程 1 已获取 lock1正在尝试获取 lock2...
线程 2 已获取 lock2正在尝试获取 lock1...之后程序就会停滞因为发生了死锁。
2. 如何避免死锁
在多线程编程里死锁是一个常见且棘手的问题它指的是两个或多个线程相互等待对方释放锁从而导致所有线程都无法继续执行的情况。以下是一些避免死锁问题的有效方法
1 按顺序获取锁
多个线程在需要获取多个锁时如果都按照相同的顺序获取锁就能避免死锁。例如假设有两个锁 lockA 和 lockB所有线程都先获取 lockA 再获取 lockB这样就不会出现一个线程持有 lockA 等待 lockB而另一个线程持有 lockB 等待 lockA 的情况。
using System;
using System.Threading;class Program
{private static readonly object lockA new object();private static readonly object lockB new object();static void Main(){Thread thread1 new Thread(() {lock (lockA){Console.WriteLine(Thread 1 acquired lockA);Thread.Sleep(100);lock (lockB){Console.WriteLine(Thread 1 acquired lockB);}}});Thread thread2 new Thread(() {lock (lockA){Console.WriteLine(Thread 2 acquired lockA);Thread.Sleep(100);lock (lockB){Console.WriteLine(Thread 2 acquired lockB);}}});thread1.Start();thread2.Start();thread1.Join();thread2.Join();}
}2 设置锁的超时时间
为锁操作设置超时时间当线程在规定时间内无法获取锁时就放弃获取锁并进行其他处理。这样可以避免线程无限期地等待锁从而打破死锁的条件。在 C# 中可以使用 Monitor.TryEnter 方法来实现这一点。
using System;
using System.Threading;class Program
{private static readonly object lockA new object();private static readonly object lockB new object();static void Main(){Thread thread1 new Thread(() {if (Monitor.TryEnter(lockA, 1000)){try{Console.WriteLine(Thread 1 acquired lockA);if (Monitor.TryEnter(lockB, 1000)){try{Console.WriteLine(Thread 1 acquired lockB);}finally{Monitor.Exit(lockB);}}}finally{Monitor.Exit(lockA);}}});Thread thread2 new Thread(() {if (Monitor.TryEnter(lockA, 1000)){try{Console.WriteLine(Thread 2 acquired lockA);if (Monitor.TryEnter(lockB, 1000)){try{Console.WriteLine(Thread 2 acquired lockB);}finally{Monitor.Exit(lockB);}}}finally{Monitor.Exit(lockA);}}});thread1.Start();thread2.Start();thread1.Join();thread2.Join();}
}3 减少锁的嵌套
锁的嵌套会增加死锁的风险因为嵌套的锁会使线程持有多个锁的时间变长增加了与其他线程发生死锁的可能性。尽量减少锁的嵌套将需要锁保护的代码逻辑拆分成更小的部分只在必要时使用锁。
4 使用资源层次结构
为共享资源定义一个层次结构线程只能按照资源的层次顺序获取锁。例如将资源分为不同的级别线程必须先获取高级别的资源锁再获取低级别的资源锁。这样可以确保线程获取锁的顺序是一致的避免死锁。
5 使用无锁算法和数据结构
在某些情况下可以使用无锁算法和数据结构来替代传统的锁机制。无锁算法和数据结构通过原子操作如 Interlocked 类提供的方法来实现线程安全避免了锁的使用从而从根本上消除了死锁的可能性。例如使用 ConcurrentQueue、ConcurrentDictionaryTKey, TValue 等并发集合类。
6 死锁检测和恢复机制
在程序中实现死锁检测机制定期检查是否存在死锁情况。如果检测到死锁可以采取一些恢复措施如终止某些线程或释放某些锁以打破死锁状态。不过死锁检测和恢复机制的实现比较复杂需要根据具体的应用场景进行设计。
五、lock 的实现原理
lock 关键字实际上是 Monitor 类的语法糖上述 lock 语句等价于以下代码
object obj lockObject;
bool lockTaken false;
try
{Monitor.Enter(obj, ref lockTaken);// 要保护的代码块sharedCounter;
}
finally
{if (lockTaken){Monitor.Exit(obj);}
}Monitor.Enter 方法用于获取锁对象的锁Monitor.Exit 方法用于释放锁对象的锁。try-finally 块确保无论 lock 块内的代码是否抛出异常锁都会被正确释放。
六、适用场景
lock 关键字适用于需要保护共享资源的多线程场景例如
对共享变量的读写操作如上面示例中的计数器。对共享集合的操作如对 List、DictionaryTKey, TValue 等集合的添加、删除、修改操作。对共享文件、数据库连接等资源的访问。对于高并发场景考虑使用 ReaderWriterLockSlim 等更灵活的同步机制。
七、其他
在异步编程 async 和 await 中传统的 lock 并不适合因为它会导致线程阻塞。取而代之的是你应该考虑使用 SemaphoreSlim 或 AsyncLock 等替代方案。
using System.Threading;
using System.Threading.Tasks;public class AsyncCounter
{private int _count 0;private readonly SemaphoreSlim _semaphore new SemaphoreSlim(1, 1);public async Task IncrementAsync(){await _semaphore.WaitAsync();try{_count;}finally{_semaphore.Release();}}
}总之lock 关键字是 C# 中一种简单而有效的同步机制能够帮助开发者确保多线程环境下共享资源的安全访问。但在使用时需要注意锁对象的选择、锁的粒度和避免死锁等问题。 结语
回到目录页C#/.NET 知识汇总 希望以上内容可以帮助到大家如文中有不对之处还请批评指正。 参考资料 lock 语句 - 确保对共享资源的独占访问权限 Locker 和 Monitor 锁 C#多线程系列2多线程锁lock和Monitor
