🔑 简单来讲讲C#锁#

✨ 前言#

今天来说说C#中的锁，锁在日常开发中还是很常用的，但是用的不得当，或者骚操作比较多那么就会导致死锁，从而导致系统崩溃。

后面我会出一系列文章，来讲讲C#里面的代码和技巧，通过不断的学习积累，以达到我的跳槽目标。

文章中有任何错误的地方都可以指出，博主也在不断的学习中~

📖 简述#

下面问问AI来简单了解下什么是锁，AI分析还是挺详细的。

🧩 通俗理解#

在现实生活里，锁就像一把门锁。
如果一个人进了房间并把门反锁，别人就得在外面等他出来。
等里面的人出来并开锁后，下一个人才能进去。

👉 编程里的“锁”也是一样的：它保证同一时刻只有一个线程能进入临界区（共享资源的代码块），从而避免混乱。

⚙️ 技术定义#

在 并发编程 中，**锁（Lock）**是一种同步机制，用来 控制多个线程对共享资源的并发访问。

没有锁时：多个线程可能同时修改同一个变量、文件、数据库记录 → 造成 数据竞争 (Race Condition)。
有了锁后：一个线程进入临界区时，其它线程必须等待 → 保证 数据一致性。

🔒 锁的关键特性#

互斥性
- 一次只能有一个线程持有锁。
- 其他线程必须等待。
可见性
- 线程释放锁前的修改，对之后获取锁的线程是可见的。
可重入性（C# 的 lock 是可重入的）
- 同一线程可以多次进入同一把锁，而不会死锁自己。

💡 举例#

下面就举个例子讲讲什么情况下就需要用到锁。

1
int a = 0;
2

3
// 并行++
4
Parallel.For(0, 1000, _ => {
5
    a++;
6
});
7

8
// 会发现 a 的值小于 1000，因为并行操作导致了线程之间的竞争。
9
Console.WriteLine(a);

正常情况下，a的值应该是等于1000的，但由于这里使用了Parallel.For，会导致多个线程对同一个值进行++操作，从而导致最终的结果没有1000次。

那么如何避免这种情况呢，可以使用锁去避免。

1
// 使用锁解决线程竞争问题
2
object obj = new object();
3

4
int b = 0;
5

6
Parallel.For(0, 1000, _ => {
7
    lock (obj) {
8
        b++;
9
    }
10
});
11

12
// 现在 b 的值一定是 1000，因为锁确保了同一时间只有一个线程可以执行 b++ 操作。
13
Console.WriteLine(b);

这里使用了一个object类型作为锁对象，这也是常见的锁对象，不一定非得使用object类型，其他引用类型也行。

🖼️ 运行结果#

🚀 .net9 新的锁对象#

上面已经通过简单的例子了解到了什么是锁，已经怎么使用锁，那么在.net9中可以直接使用lock对象作为锁。

ℹ️ 在使用.net9创建项目时，如果使用object类型的锁，rider编辑器会提示使用Lock类型作为锁。

⏳ 老写法#

1
public class Lock
2
{
3
    private readonly object _lock = new();
4
    public void Foo()
5
    {
6
        lock (_lock)
7
        {
8
            Thread.Sleep(3000);
9
            Console.WriteLine("In Foo");
10
        }
11
    }
12
}

⚡ 新写法#

1
public class Deadlock
2
{
3
    private readonly Lock _lock = new();
4
    public void Foo()
5
    {
6
        lock (_lock)
7
        {
8
            Thread.Sleep(3000);
9
            Console.WriteLine("In Foo");
10
        }
11
    }
12
}

📊 比较#

特性	传统的 `object` + `lock(obj)`（Monitor-based）	用 `System.Threading.Lock` + `lock(newLock)`
锁对象类型意图性	任意引用类型，不专门为锁“设计”	专门的锁类型，用意明确
编译器识别/处理	用 `Monitor.Enter/Exit`； `lock(object)` 被编译器转换为 Monitor 操作	如果 `lock` 的目标是 `Lock` 类型，编译器 special-case 使用 `EnterScope()/Dispose()` 的新方式
内部机制	使用 `Monitor`、SyncBlocks、Thin locks 等，涉及 object header，可能有额外开销	新语义可以减少某些 Monitor 的开销，scope 块式释放锁，可能在某些场景性能更优
性能	在高并发且锁竞争严重的场景下性能可能成为瓶颈	在同样场景下可有更好的性能（但具体提升依赖于运行情况和 contention）
可读性／安全性	用 `object`，可能误用；不容易一眼看出这是锁对象	用 `Lock` 类型，代码语义直接告诉你“这是用来加锁的”