C# 多线程调试与最佳实践

// 在线程启动后立即设置名称
Thread.CurrentThread.Name = $"Worker-{taskId}";

// 在调试器中可以直接识别

// 死锁示例
object lockA = new object();
object lockB = new object();

// 线程 1
lock (lockA)
{
    Thread.Sleep(100);
    lock (lockB) { }  // 等待 lockB
}

// 线程 2
lock (lockB)
{
    Thread.Sleep(100);
    lock (lockA) { }  // 等待 lockA
}

// 诊断方法：
// 1. 在 VS 中中断执行
// 2. 打开"调试 → 窗口 → 线程"
// 3. 查看每个线程的调用堆栈，找出都在等待什么锁
// 4. 使用"并行堆栈"窗口可视化

// 策略1：固定锁顺序
// 所有线程按相同顺序获取锁（lockA 然后 lockB）

// 策略2：使用超时
if (Monitor.TryEnter(lockA, TimeSpan.FromSeconds(1)))
{
    try
    {
        if (Monitor.TryEnter(lockB, TimeSpan.FromSeconds(1)))
        {
            try { /* 临界区 */ }
            finally { Monitor.Exit(lockB); }
        }
    }
    finally { Monitor.Exit(lockA); }
}

// 策略3：使用 AsyncLock 配合超时
if (await asyncLock.LockAsync(TimeSpan.FromSeconds(1)))
{
    using (release) { /* 临界区 */ }
}

// 现象：某些线程长时间得不到 CPU
// 原因：
// 1. 高优先级线程持续占用
// 2. 锁竞争过于激烈
// 3. 线程池耗尽

// 诊断：
// 1. 检查 Thread.CurrentThread.Priority
// 2. 使用性能监视器查看线程队列长度
// 3. 使用 ThreadPool.GetAvailableThreads

int worker, io;
ThreadPool.GetAvailableThreads(out worker, out io);
Console.WriteLine($"可用线程: {worker}, 可用 IO: {io}");

if (worker < 10)
{
    Console.WriteLine("警告：线程池接近耗尽");
}

// 使用 PerformanceCounter 监测
using System.Diagnostics;

// 当前线程数
var threadCount = new PerformanceCounter(
    "Process", 
    "Thread Count", 
    Process.GetCurrentProcess().ProcessName);

Console.WriteLine($"当前线程数: {threadCount.NextValue()}");

// 使用 System.Diagnostics.Tracing 记录事件
[EventSource(Name = "MyApp")]
public class MyEventSource : EventSource
{
    public static MyEventSource Log = new MyEventSource();
    
    [Event(1, Level = EventLevel.Informational)]
    public void ThreadStart(int threadId, string name)
    {
        WriteEvent(1, threadId, name);
    }
    
    [Event(2, Level = EventLevel.Warning)]
    public void LockContention(int waitMs)
    {
        WriteEvent(2, waitMs);
    }
}

// 使用
MyEventSource.Log.ThreadStart(Thread.CurrentThread.ManagedThreadId, name);

using System.Collections.Concurrent;

public class ThreadSafeLogger
{
    private readonly ConcurrentQueue<string> _logQueue = new ConcurrentQueue<string>();
    private readonly string _logFile;
    
    public ThreadSafeLogger(string logFile)
    {
        _logFile = logFile;
    }
    
    public void Log(string message)
    {
        string timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
        string threadId = Thread.CurrentThread.ManagedThreadId.ToString();
        string logEntry = $"[{timestamp}] [Thread {threadId}] {message}";
        
        _logQueue.Enqueue(logEntry);
        
        // 异步写入
        Task.Run(() => Flush());
    }
    
    private void Flush()
    {
        while (_logQueue.TryDequeue(out string entry))
        {
            File.AppendAllText(_logFile, entry + Environment.NewLine);
        }
    }
}

// 使用
var logger = new ThreadSafeLogger("app.log");
logger.Log("开始处理");

using Microsoft.Extensions.Logging;

public class Worker
{
    private readonly ILogger<Worker> _logger;
    
    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }
    
    public async Task RunAsync(CancellationToken token)
    {
        _logger.LogInformation("线程 {ThreadId} 开始工作", 
            Thread.CurrentThread.ManagedThreadId);
        
        while (!token.IsCancellationRequested)
        {
            try
            {
                await DoWorkAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "工作线程异常");
            }
        }
    }
}

// ❌ 避免
Thread t = new Thread(() => DoWork());
t.Start();

// ✅ 推荐
await Task.Run(() => DoWork());

// ❌ 避免
bool _isCancelled;
while (!_isCancelled) { }

// ✅ 推荐
while (!token.IsCancellationRequested) { }

// ❌ 避免
int sharedCounter = 0;
Parallel.For(0, 1000, i => sharedCounter++);

// ✅ 使用线程局部聚合
int total = 0;
Parallel.For(0, 1000, 
    () => 0,
    (i, state, local) => local + 1,
    local => Interlocked.Add(ref total, local));

// ❌ 避免（事件处理除外）
public async void DoWorkAsync() { }

// ✅ 推荐
public async Task DoWorkAsync() { }

// 例外：UI 事件
private async void Button_Click(object sender, EventArgs e)
{
    await LoadDataAsync();
}

// ❌ 避免：静默失败
Task.Run(() => {
    MightThrowException();  // 异常丢失
});

// ✅ 推荐：总是处理异常
Task.Run(() => {
    try { MightThrowException(); }
    catch (Exception ex) 
    { 
        Logger.LogError(ex, "任务异常");
    }
});

// 或等待并捕获
try { await task; }
catch (Exception ex) { Handle(ex); }

// ❌ 避免
Thread.Sleep(1000);

// ✅ 推荐
await Task.Delay(1000);

// 库代码中
await DoWorkAsync().ConfigureAwait(false);

// UI 应用中需要更新 UI 时
var data = await FetchDataAsync();  // 恢复上下文
this.TextBox.Text = data;