// 死鎖示例
object lock1 = new object();
object lock2 = new object();

// 線程A
Task.Run(() =>
{
    lock (lock1)
    {
        Thread.Sleep(100);
        lock (lock2)
        {
            Console.WriteLine("Thread A got both locks");
        }
    }
});

// 線程B
Task.Run(() =>
{
    lock (lock2)
    {
        Thread.Sleep(100);
        lock (lock1)
        {
            Console.WriteLine("Thread B got both locks");
        }
    }
});

// 經(jīng)典的同步上下文死鎖
private async void Button_Click(object sender, EventArgs e)
{
    // 在UI線程中調(diào)用
    var result = GetResultAsync().Result; // 死鎖！
    label.Text = result;
}

private async Task<string> GetResultAsync()
{
    await Task.Delay(1000);
    return "Result";
}

// 線程池死鎖示例
public void ThreadPoolDeadlock()
{
    Task.Run(() =>
    {
        Task.Run(() => 
        {
            // 內(nèi)部任務(wù)需要等待外部任務(wù)完成
        }).Wait(); // 死鎖！
    }).Wait();
}

# 加載SOS擴(kuò)展
.loadby sos clr

# 查看所有線程
!threads

# 查看死鎖情況
!dlk

// 使用Monitor.TryEnter設(shè)置超時(shí)
if (Monitor.TryEnter(lockObject, TimeSpan.FromSeconds(5)))
{
    try
    {
        // 執(zhí)行臨界區(qū)代碼
    }
    finally
    {
        Monitor.Exit(lockObject);
    }
}
else
{
    // 處理超時(shí)情況，可能是死鎖
    Console.WriteLine("Lock acquisition timed out - potential deadlock!");
}

// ? 正確做法：統(tǒng)一鎖獲取順序
object lock1 = new object();
object lock2 = new object();

Task.Run(() =>
{
    // 始終按照l(shuí)ock1 -> lock2的順序獲取
    lock (lock1)
    {
        lock (lock2)
        {
            // 安全執(zhí)行
        }
    }
});

Task.Run(() =>
{
    // 也按照l(shuí)ock1 -> lock2的順序
    lock (lock1)
    {
        lock (lock2)
        {
            // 安全執(zhí)行
        }
    }
});

// 使用Monitor.TryEnter避免無(wú)限等待
public bool TryAcquireLock(object lockObject, TimeSpan timeout)
{
    if (Monitor.TryEnter(lockObject, timeout))
    {
        try
        {
            // 執(zhí)行臨界區(qū)代碼
            return true;
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }
    return false; // 超時(shí)，可能死鎖
}

// ? 正確做法：使用async/await
private async void Button_Click(object sender, EventArgs e)
{
    var result = await GetResultAsync();
    label.Text = result;
}

// 或者使用ConfigureAwait(false)
private async Task<string> GetResultAsync()
{
    await Task.Delay(1000).ConfigureAwait(false);
    return "Result";
}

// 使用SemaphoreSlim替代多個(gè)lock
private SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

public async Task SafeOperationAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        // 執(zhí)行臨界區(qū)代碼
    }
    finally
    {
        _semaphore.Release();
    }
}

// 使用ReaderWriterLockSlim實(shí)現(xiàn)讀寫(xiě)分離
private ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

public void ReadOperation()
{
    _rwLock.EnterReadLock();
    try
    {
        // 讀取操作
    }
    finally
    {
        _rwLock.ExitReadLock();
    }
}

// ? 正確做法
public async Task ProcessDataAsync()
{
    var task1 = GetData1Async();
    var task2 = GetData2Async();
    
    await Task.WhenAll(task1, task2);
    
    var result1 = await task1;
    var result2 = await task2;
    
    // 處理結(jié)果
}

// ? 錯(cuò)誤做法
lock (lockObject)
{
    var data = GetDataFromDatabase(); // 耗時(shí)操作
    ProcessData(data);
}

// ? 正確做法
var data = GetDataFromDatabase(); // 先獲取數(shù)據(jù)
lock (lockObject)
{
    ProcessData(data); // 只鎖定必要的代碼
}

// ? 推薦使用lock語(yǔ)句（自動(dòng)處理異常情況）
lock (lockObject)
{
    // 臨界區(qū)代碼
}

// 而不是手動(dòng)使用Monitor
Monitor.Enter(lockObject);
try
{
    // 臨界區(qū)代碼
}
finally
{
    Monitor.Exit(lockObject);
}

// ? 危險(xiǎn)做法
lock (lockObject)
{
    callback(); // 外部回調(diào)可能持有其他鎖
}

// ? 安全做法
var localData = GetData();
callback(localData); // 在鎖外調(diào)用
lock (lockObject)
{
    UpdateState(localData);
}

// 實(shí)現(xiàn)異步鎖
public class AsyncLock
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    private readonly Task<IDisposable> _releaser;
    
    public AsyncLock()
    {
        _releaser = Task.FromResult((IDisposable)new Releaser(this));
    }
    
    public Task<IDisposable> LockAsync()
    {
        var wait = _semaphore.WaitAsync();
        return wait.IsCompleted ?
            _releaser :
            wait.ContinueWith((_, state) => (IDisposable)state,
                _releaser.Result, TaskScheduler.Default);
    }
    
    private sealed class Releaser : IDisposable
    {
        private readonly AsyncLock _lock;
        public Releaser(AsyncLock @lock) => _lock = @lock;
        public void Dispose() => _lock._semaphore.Release();
    }
}

// 使用示例
private readonly AsyncLock _asyncLock = new AsyncLock();

public async Task SafeAsyncOperation()
{
    using (await _asyncLock.LockAsync())
    {
        // 異步臨界區(qū)代碼
    }
}