C# 锁机制原理深入解析

无锁 (fast path)  →  薄锁 thin lock   →  厚锁 heavy lock
     ↑                    ↑                     ↑
 无竞争访问          少量短暂竞争           多线程激烈竞争
  ~2ns              ~20-50ns（自旋）       ~200ns+（含内核切换与挂起）

// 无竞争时，底层大致等价于：
// 一条 cas 指令操作对象头 → 成功就直接进入临界区
lock (_lock)
{
    _x = 1;
}

private readonly lock _lock = new();
public void update()
{
    lock (_lock)   // c# 13 起 lock 语句原生支持 lock 类型
    {
        // ...
    }
}

// 简化版内部逻辑
public struct spinwait
{
    private int _count;
    public void spinonce()
    {
        if (_count < 10)
        {
            // 阶段1：纯 pause/yield 指令（约前 10 次）
            thread.spinwait(4 << _count); // 指数增长的 pause 循环
        }
        else if (_count < 20)
        {
            // 阶段2：thread.yield()，让出给同优先级线程
            thread.yield();
        }
        else
        {
            // 阶段3：thread.sleep(0)/sleep(1)，主动放弃时间片
            if ((_count & 1) == 0)
                thread.sleep(0);
            else
                thread.sleep(1);
        }
        _count++;
    }
}

// 错误1：零退避死循环，制造总线风暴
while (interlocked.compareexchange(ref _flag, 1, 0) != 0) { }
// 错误2：固定 sleep，最小粒度 1ms，远超多数锁持有时间
while (interlocked.compareexchange(ref _flag, 1, 0) != 0)
{
    thread.sleep(1);
}
// 正确1：spinwait 自适应退避
var spinner = new spinwait();
while (interlocked.compareexchange(ref _flag, 1, 0) != 0)
{
    spinner.spinonce();
}
// 正确2：再加超时保护，避免逻辑 bug 导致永久自旋
var spinner = new spinwait();
var sw = stopwatch.startnew();
while (interlocked.compareexchange(ref _flag, 1, 0) != 0)
{
    if (sw.elapsedmilliseconds > 100)
        throw new timeoutexception("获取锁超时");
    spinner.spinonce();
}

// 错误：锁内做 io，持锁时间被拉到秒级
lock (_lock)
{
    var data = file.readalltext(_path); // 千万别
    _cache = data;
}
// 正确：锁外读，锁内只赋值
var data = file.readalltext(_path);
lock (_lock) { _cache = data; }

public class stripedcounter
{
    private readonly object[] _stripes;
    private readonly int[] _counts;
    public stripedcounter(int stripecount)
    {
        _stripes = enumerable.range(0, stripecount).select(_ => new object()).toarray();
        _counts = new int[stripecount];
    }
    public void increment(int key)
    {
        int idx = (key & 0x7fffffff) % _stripes.length;
        lock (_stripes[idx]) { _counts[idx]++; }
    }
}

// 错误示范：_instance 没有 volatile 也没有 interlocked
if (_instance == null)
{
    lock (_lock)
    {
        if (_instance == null)
            _instance = new expensiveobject();
    }
}
return _instance;

// 方案1：volatile 字段 + dcl（官方推荐的标准写法）
private static volatile expensiveobject? _instance;
private static readonly object _lock = new();
public static expensiveobject instance
{
    get
    {
        if (_instance is null)
        {
            lock (_lock)
            {
                _instance ??= new expensiveobject();
            }
        }
        return _instance;
    }
}
// 方案2：lazy<t>（最省心，无需手写任何锁）
private static readonly lazy<expensiveobject> _lazy =
    new(() => new expensiveobject(), lazythreadsafetymode.executionandpublication);
public static expensiveobject getinstance() => _lazy.value;
// 方案3：interlocked.compareexchange（全屏障，跨运行时最强保证）
public static expensiveobject getinstancestrong()
{
    if (_instance is null)
    {
        lock (_lock)
        {
            interlocked.compareexchange(ref _instance, new expensiveobject(), null);
            // 注意：构造函数可能被多个线程各执行一次，只有一个实例留下
            // 工厂必须无副作用，否则改用 lazy<t>
        }
    }
    return _instance;
}

private volatile bool _stoprequested;
// 生产者/控制线程
_stoprequested = true;  // volatile 写：保证之前的数据写入对其他线程可见
// 消费者工作线程
while (!_stoprequested) // volatile 读：保证每次读到最新值
{
    processitem();
}

// thread.memorybarrier()：全屏障，阻止前后读写重排
// interlocked.memorybarrier()：同上，.net core 3.0+ 推荐（更明确属于原子操作语义）
private int _data;
private volatile bool _ready;
void producer()
{
    _data = 42;
    interlocked.memorybarrier(); // 确保 _data 的写在 _ready=true 之前对其他线程可见
    _ready = true;
}
void consumer()
{
    if (_ready)
    {
        interlocked.memorybarrier(); // 双保险，确保读到 _ready=true 后能看到 _data 的写
        console.writeline(_data);  // 此处必为 42
    }
}

// 线程 a：先拿锁1再拿锁2
lock (_lock1) { lock (_lock2) { doa(); } }
// 线程 b：先拿锁2再拿锁1
lock (_lock2) { lock (_lock1) { dob(); } }

// 约定：所有地方都先拿 _lock1 再拿 _lock2，永不反序
private static readonly object _lock1 = new();
private static readonly object _lock2 = new();
void transfera()
{
    lock (_lock1) { lock (_lock2) { /* ... */ } }
}
void transferb()
{
    lock (_lock1) { lock (_lock2) { /* ... */ } }  // 也按 1→2 顺序
}

bool lockboth(int timeoutms)
{
    bool got1 = false, got2 = false;
    try
    {
        got1 = monitor.tryenter(_lock1, timeoutms);
        if (!got1) return false;
        got2 = monitor.tryenter(_lock2, timeoutms);
        if (!got2) return false;
        dowork();
        return true;
    }
    finally
    {
        if (got2) monitor.exit(_lock2);
        if (got1) monitor.exit(_lock1);
    }
}
// 调用：失败则退避重试，避免永久死锁
while (!lockboth(1000))
{
    thread.spinwait(100);
    if (++retries > 10) throw new invalidoperationexception("获取锁超时");
}

// 类库代码
public async task loaddataasync()
{
    await _semaphore.waitasync();
    try
    {
        var data = await fetchfromdbasync(); // 挂起在这里，永不返回
        _cache.update(data);
    }
    finally { _semaphore.release(); }
}
// 调用方（ui / wcf / asp.net classic）
button_click(...)
{
    loaddataasync().wait(); // 同步阻塞等待异步方法
}

await _semaphore.waitasync().configureawait(false);
var data = await fetchfromdbasync().configureawait(false);

// 调用方也改为 async，不阻塞任何线程
private async void button_click(...)
{
    await loaddataasync();
}

// 丢到线程池执行，脱离当前 sc
await task.run(() => loaddataasync()).configureawait(false);

private readonly channel<func<task>> _workqueue =
    channel.createbounded<func<task>>(1);
public async task executeserialasync(func<task> work)
{
    await _workqueue.writer.writeasync(work);
}
// 后台单消费者，天然串行、无锁
private async task processloopasync(cancellationtoken ct)
{
    await foreach (var work in _workqueue.reader.readallasync(ct))
    {
        await work();
    }
}

public sealed class asynclock : idisposable
{
    private readonly semaphoreslim _semaphore = new(1, 1);
    public async task<idisposable> lockasync(cancellationtoken ct = default)
    {
        await _semaphore.waitasync(ct).configureawait(false);
        return new releaser(_semaphore);
    }
    private readonly struct releaser : idisposable
    {
        private readonly semaphoreslim _s;
        public releaser(semaphoreslim s) => _s = s;
        public void dispose() => _s.release();
    }
    public void dispose() => _semaphore.dispose();
}
// 用法
await using var scope = await _asynclock.lockasync(ct);
// 临界区...

// 危险：在析构函数（终结器）中获取锁
~myresource()
{
    lock (_globallock) // 终结器线程尝试获取锁
    {
        cleanup();
    }
}

// 1. 终结器中绝不获取任何锁，只做非托管资源释放，且不调用任何可能阻塞的方法
~myresource()
{
    nativemethods.free(_handle);
}
// 2. 优先用 safehandle 替代手写 finalize，框架已处理好终结安全
private readonly safefilehandle _handle;

// 推荐：小对象 + 专用 + 长生命周期
private readonly object _lock = new();
// .net 9+：专用锁类型
private readonly lock _lock9 = new();
// 按需启用 loh 压缩（.net core 3.0+），缓解大对象碎片
gcsettings.largeobjectheapcompactionmode = gclargeobjectheapcompactionmode.compactonce;

锁的实际持有时间 = 临界区代码执行时间 + gc 暂停时间

请求qps↑ → 线程被同步调用卡住 → 队列堆积 → 线程池每秒只加1线程 → 堆积速度远超扩容 → 饥饿

// 危险组合：锁内同步阻塞 io，线程池线程被钉死
public string getdata(int id)
{
    lock (_lock)
    {
        return _httpclient.getstringasync($"/api/{id}").result; // 双重罪
    }
}

public async task<string> getdataasync(int id, cancellationtoken ct)
{
    await _semaphore.waitasync(ct).configureawait(false);
    try
    {
        return await _httpclient.getstringasync($"/api/{id}", ct).configureawait(false);
    }
    finally { _semaphore.release(); }
}

// 启动时配置，让线程池敢于更快扩容
threadpool.getminthreads(out int wt, out int _);
threadpool.setminthreads(math.max(wt, 200), math.max(wt, 200));

threadpool.getavailablethreads(out int worker, out int io);
threadpool.getmaxthreads(out int maxworker, out _);
if (worker < maxworker * 0.1)
    _logger.warn("线程池接近耗尽: 可用={worker}", worker);

// 构造时显式指定不支持递归
private readonly readerwriterlockslim _rwlock =
    new(lockrecursionpolicy.norecursion);

public class fairreadwritelock
{
    private readonly readerwriterlockslim _rwlock = new();
    private readonly semaphoreslim _readergate = new(10, 10); // 最多 10 个并发读者
    public void read(action action)
    {
        _readergate.wait(); // 读者过多时阻塞新读者，给写者留出窗口
        try
        {
            _rwlock.enterreadlock();
            try { action(); }
            finally { _rwlock.exitreadlock(); }
        }
        finally { _readergate.release(); }
    }
    public void write(action action)
    {
        _rwlock.enterwritelock();
        try { action(); }
        finally { _rwlock.exitwritelock(); }
    }
}

public class optimisticreadwritecache<t>
{
    private t _value = default!;
    private int _version;                       // 偶数=稳定可读，奇数=写入中
    private readonly object _writelock = new(); // 写者之间互斥
    public bool tryread(out t value)
    {
        int v1 = volatile.read(ref _version);
        if ((v1 & 1) != 0) { value = default!; return false; }  // 写入中，本次读失败
        t snapshot = volatile.read(ref _value);                 // 读取数据快照
        int v2 = volatile.read(ref _version);
        if (v1 != v2 || (v2 & 1) != 0)
        {
            value = default!;
            return false;                                      // 期间发生过写入，重试
        }
        value = snapshot;
        return true;
    }
    public void write(t newvalue)
    {
        lock (_writelock)
        {
            interlocked.increment(ref _version);  // 变奇数：宣告写入中
            volatile.write(ref _value, newvalue);
            interlocked.increment(ref _version);  // 变偶数：宣告稳定
        }
    }
}

public sealed class immutableconfig
{
    public string endpoint { get; }
    public int timeout { get; }
    public immutableconfig(string endpoint, int timeout)
    {
        endpoint = endpoint;
        timeout = timeout;
    }
}
public class configstore
{
    // volatile 保证写的可见性，引用赋值本身已原子
    private volatile immutableconfig _current = new("default", 30);
    public immutableconfig current => _current;
    public void update(string endpoint, int timeout)
    {
        // 构造完整新对象，再原子替换引用
        _current = new immutableconfig(endpoint, timeout);
    }
}

// 写者并发安全版：cas 重试，避免丢更新
public void update(string endpoint, int timeout)
{
    var updated = new immutableconfig(endpoint, timeout);
    var original = _current;
    while (interlocked.compareexchange(ref _current, updated, original) != original)
    {
        original = _current; // 被别人抢先了，基于最新值重试
    }
}

字段布局：[ _counta (4b) | _countb (4b) | <padding> ]  ← 同一 64 字节缓存行
核心1 高频写 _counta：
  → 整条缓存行在核心2 的 l1 失效
核心2 高频写 _countb：
  → 整条缓存行在核心1 的 l1 失效
  → 核心2 重新拉缓存行（含 _counta，虽然它根本不读）
  → 核心1 再写 _counta，核心2 又失效……

// 危险：两个计数器紧挨着，落在同一缓存行
public class naivecounter
{
    private int _counta;
    private int _countb;
    public void inca() => interlocked.increment(ref _counta);
    public void incb() => interlocked.increment(ref _countb);
}

// 把计数器放进 struct，用 structlayout 显式控制布局
[structlayout(layoutkind.explicit, size = 128)] // 占 2 个缓存行
internal struct paddedcounter
{
    [fieldoffset(0)]  public int value;
    [fieldoffset(64)] public int padding; // 仅占位，保证下一字段在新缓存行
}
public class parallelcounter
{
    private paddedcounter _a;
    private paddedcounter _b;   // _a 和 _b 各自独占缓存行
    public void inca() => interlocked.increment(ref _a.value);
    public void incb() => interlocked.increment(ref _b.value);
}

// 简化做法：每个计数器独立对象，靠 gc 堆自然分离（不保证但通常有效）
public sealed class paddedcounter
{
    // 56 字节 padding + 4 字节 value ≈ 一个缓存行
    private readonly int[] _padding = new int[14];
    private int _value;
    public int value => _value;
    public void increment() => interlocked.increment(ref _value);
}

public bool doworkwithtimeout(int timeoutms)
{
    if (!monitor.tryenter(_lock, timeoutms))
        return false; // 拿锁超时，调用方决定降级或重试
    try
    {
        doactualwork();
        return true;
    }
    finally { monitor.exit(_lock); }
}

public async task<bool> doworkasync(cancellationtoken ct)
{
    try
    {
        await _semaphore.waitasync(ct).configureawait(false);
    }
    catch (operationcanceledexception)
    {
        return false; // 取消，优雅降级
    }
    try
    {
        await doactualworkasync(ct).configureawait(false);
        return true;
    }
    finally { _semaphore.release(); }
}

public async task<bool> doworkrobustasync(cancellationtoken externalct)
{
    // 外部 ct + 自带超时，组合成新的 ct
    using var cts = cancellationtokensource.createlinkedtokensource(externalct);
    cts.cancelafter(timespan.fromseconds(5));
    try
    {
        await _semaphore.waitasync(cts.token).configureawait(false);
    }
    catch (operationcanceledexception) when (externalct.iscancellationrequested)
    {
        return false; // 外部取消
    }
    catch (operationcanceledexception)
    {
        throw new timeoutexception("等锁超过 5 秒，疑似死锁"); // 超时
    }
    try
    {
        await doactualworkasync(cts.token).configureawait(false);
        return true;
    }
    finally { _semaphore.release(); }
}