C#中如何实现一对一多线程关系及异常处理

一、优雅的线程批量创建实现 #

针对Dictionary<int,A>集合中每个A对象的独立线程需求，可通过封装线程管理类批量创建并管理线程，避免重复手动创建逻辑：

using System;
using System.Collections.Generic;
using System.Threading;

public class ThreadManager
{
    private readonly List<Thread> _runningThreads = new List<Thread>();
    
    // 启动所有A对象的任务线程
    public void LaunchAllTasks(Dictionary<int, A> items)
    {
        foreach (var kvp in items)
        {
            // 用Lambda直接绑定A对象，避免参数类型转换
            Thread taskThread = new Thread(() => RunTask(kvp.Value));
            // 设置为后台线程，防止子线程未完成阻塞程序退出
            taskThread.IsBackground = true;
            _runningThreads.Add(taskThread);
            taskThread.Start();
        }
    }

    // 单个A对象的任务执行逻辑
    private void RunTask(A item)
    {
        try
        {
            // 替换为A对象需要执行的具体操作
            item.ExecuteOperation();
        }
        catch (Exception ex)
        {
            // 捕获子线程异常后，通过事件传递到主线程
            RaiseTaskException(ex);
        }
    }

    // 异常传递事件
    public event EventHandler<ExceptionEventArgs> TaskFailed;

    private void RaiseTaskException(Exception ex)
    {
        TaskFailed?.Invoke(this, new ExceptionEventArgs(ex));
    }

    // 可选：统一终止所有线程（需注意线程安全）
    public void StopAllTasks()
    {
        foreach (var thread in _runningThreads)
        {
            if (thread.IsAlive)
            {
                thread.Abort(); // 注意：Thread.Abort不推荐用于生产环境，仅作示例，实际需设计优雅终止逻辑
            }
        }
        _runningThreads.Clear();
    }
}

// 自定义异常事件参数
public class ExceptionEventArgs : EventArgs
{
    public Exception Exception { get; }

    public ExceptionEventArgs(Exception ex)
    {
        Exception = ex;
    }
}

// 示例A类
public class A
{
    public void ExecuteOperation()
    {
        // 模拟业务操作，可能抛出异常
        if (new Random().Next(0, 2) == 0)
        {
            throw new InvalidOperationException("模拟子线程异常");
        }
        Console.WriteLine($"A对象操作完成，线程ID：{Thread.CurrentThread.ManagedThreadId}");
    }
}

二、主线程捕获子线程异常的实现 #

子线程的异常无法直接通过主线程的try-catch捕获，通过事件订阅机制可将子线程异常安全传递到主线程处理，同时不阻塞主线程：

// 主线程使用示例
class Program
{
    static void Main(string[] args)
    {
        ThreadManager manager = new ThreadManager();
        // 订阅子线程异常事件，在主线程处理
        manager.TaskFailed += (sender, e) =>
        {
            Console.WriteLine($"主线程捕获子线程异常：{e.Exception.Message}");
            // 这里可添加日志记录、告警等逻辑
        };

        // 构造测试集合
        Dictionary<int, A> items = new Dictionary<int, A>
        {
            {1, new A()},
            {2, new A()},
            {3, new A()}
        };

        // 启动所有子线程，主线程立即继续执行后续逻辑
        manager.LaunchAllTasks(items);

        // 主线程执行自身任务，不受子线程阻塞
        Console.WriteLine("主线程正在执行其他业务逻辑...");
        // 模拟主线程持续运行
        Console.ReadLine();
    }
}

三、关键注意事项 #

• 后台线程设置：将子线程标记为IsBackground = true，确保主线程退出时，未完成的子线程会自动终止，避免程序挂起。
• 线程安全：如果A对象的操作涉及共享资源（如全局变量、数据库连接等），需使用lock或其他同步机制避免竞态条件：

  private static readonly object _syncLock = new object();
  
  private void RunTask(A item)
  {
      try
      {
          lock (_syncLock)
          {
              item.ExecuteOperation();
          }
      }
      catch (Exception ex)
      {
          RaiseTaskException(ex);
      }
  }
  

• 优雅终止：Thread.Abort存在不可控风险，实际生产中建议设计协作式终止逻辑（如通过volatile bool标记线程是否继续执行）。

内容的提问来源于stack exchange，提问作者Gabriele Troviso