C# 中的多线程实现方式

前言：

线程被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

下面的
DoSomething
和
Callback
方法将贯穿全文。

    private string DoSomething(string name, int millisecondsTimeout)
    {
    	Console.WriteLine($"线程{Thread.CurrentThread.ManagedThreadId:00}执行");
        Thread.Sleep(millisecondsTimeout);
        return name;
    }

    private void Callback() { Console.WriteLine("执行回调。"); }

一、使用委托开启多线程

直接使用委托进行异步，

.NET Core 已经不支持该方法，使用时将直接抛出错误

。

    Func<string, int, string> action = DoSomething;
    var asyncResult = action.BeginInvoke("JOY", 0, null, null);
    string result = action.EndInvoke(asyncResult);

二、使用Thread开启多线程

通过扩展 Thread 类创建的线程

    var thread = new Thread(() => DoSomething("JOY",0));
    thread.Start();

使用 Thread 实现回调

    private void ThreadWithCallBack(ThreadStart threadStart, Action actionCallBack)
    {
        var method = new ThreadStart(() =>
        {
            threadStart.Invoke();
            actionCallBack.Invoke();
        });
    
        new Thread(method).Start();
    }
	// 调用时
	ThreadWithCallBack(() => DoSomething("JOY", 1000), () => Callback());

实现类型 async/await 的功能，异步，非阻塞，并获取计算结果

    private Func<T> ThreadWithReturn<T>(Func<T> func)
    {
        T result = default;
        var method = new ThreadStart(() =>
        {
            result = func.Invoke();
        });
    
        var thread = new Thread(method);
        thread.Start();
    
        return new Func<T>(() =>
        {
            thread.Join();
            return result;
        });
    }
	// 调用时
    var func = ThreadWithReturn(() => DoSomething("JOY", 1000));
    var result = func.Invoke();

三、使用ThreadPool开启多线程

将方法假如线程池队列以便执行

	ThreadPool.QueueUserWorkItem(o => DoSomething("JOY", 20));

设置线程池数量

设置线程池数量是全局的

委托异步调用 Task Parrallel async/await 全部都是线程池的线程

直接使用 Thread 不受这个数量限制，（但是会占用线程池数量）

    ThreadPool.SetMaxThreads(6, 6);
    ThreadPool.SetMinThreads(2, 2);
    
    ThreadPool.GetMaxThreads(out int workerThreads, out int completionPortThreads);
    Console.WriteLine($"当前电脑最大workerThreads={workerThreads}，最大completionPortThreads={completionPortThreads}。");
    
    ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads);
    Console.WriteLine($"当前电脑最小workerThreads={workerThreads}，最小completionPortThreads={completionPortThreads}。");

使用
ManualResetEvent
等待线程池任务完成

	// 初始设置为 false 指示任务是否终止
	var mre = new ManualResetEvent(false);
    ThreadPool.QueueUserWorkItem(o =>
    {
        DoSomething("JOY", 20);
        mre.Set(); // 设置为任务已终止
    });
	
	mre.WaitOne();

四、使用Task开启多线程

使用Task开启子线程执行任务

    var task_1 = new Task(() => DoSomething("JOY", 2000));
    task_1.Start();

	var task_2 = Task.Run(() => DoSomething("JOY", 2000));

	var taskFactory = Task.Factory;
    Task task_3 = taskFactory.StartNew(() => DoSomething("JOY", 2000));

使用 Delay 方法延迟 Task

	Thread.Sleep(2000);
	// 与 Sleep(2000) 不同的时，Delay(2000) 不会阻塞当前线程，
	// 可以理解为在子线程内部加了一个 Sleep(2000).
	var task = Task.Delay(2000).ContinueWith(t => DoSomething("JOY", 20));

使用 ContinueWith 执行回调

	Task.Run(() => DoSomething("JOY", 2000)).ContinueWith(task => Callback());

获取 Task 的返回值，会阻塞

    var task = Task.Run<string>(() => DoSomething("JOY", 1000));
    string result = task.Result; // 获取返回值，会阻塞

使用 lock 实现线程安全

	// 在数据需要大量的情况下，可以使用数据分拆，安全又高效
    var formLock = new object();
    var numAsync = 0;
    for (int i = 0; i < 10000; i++)
    {
        Task.Run(() =>
        {
            // 任意时刻只有一个线程能进入方法块
            lock (formLock) { numAsync++; }
        });
    }

使用Task等待所有任务完成，会阻塞

    var taskFactory = Task.Factory;
    var taskList = new List<Task>();
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_1", 2000)));
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_2", 2000)));
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_3", 2000)));
    // 阻塞，等待所有任务都完成
    Task.WaitAll(taskList.ToArray());

等待任务完成后的回调

    var taskFactory = Task.Factory;
    var taskList = new List<Task>();
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_1", 2000)));
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_2", 2000)));
    taskList.Add(taskFactory.StartNew(() => DoSomething("JOY_3", 2000)));
    
    // 只要有一个任务完成就进行的回调, 这里的 task 就是第一个完成的 Task
    taskFactory.ContinueWhenAny(taskList.ToArray(), task => Callback());
    
    // 等待所有任务都完成后进的回调，这里的 tasks 就是任务集
    taskFactory.ContinueWhenAll(taskList.ToArray(), (tasks) => Callback());

控制 Task 的并发数量

	// 不建议用 ThreadPool.SetMaxThreads 和 ThreadPool.SetMinThreads 直接控制
    ThreadPool.SetMaxThreads(6, 6);
    ThreadPool.SetMinThreads(2, 2);
	
	// 建议使用Task状态控制
    var tasks = new List<Task>();
    for (int i = 0; i < 1000; i++)
    {
        var j = i;
        if (tasks.Count(task => task.Status != TaskStatus.RanToCompletion) >= 5)
        {
            Task.WaitAny(tasks.ToArray());
            tasks = tasks.Where(task => task.Status != TaskStatus.RanToCompletion).ToList();
        }
    
        tasks.Add(Task.Run(() => DoSomething($"JOY_{j + 1}.", 2000)));
    }

使用 Task.WaitAll 方法可以捕获多线程异常

    try
    {
        var tasks = new List<Task>();
        for (int i = 0; i < 9; i++)
        {
            var name = $"JOY_{i}";
            tasks.Add(Task.Run(() =>
            {
                if (name.Equals("JOY_0"))
                    throw new Exception("JOY_0异常");
                else if (name.Equals("JOY_1"))
                    throw new Exception("JOY_1异常");

                Console.WriteLine($"name: {name}, 成功。");
            }));
        }
        Task.WaitAll(tasks.ToArray());
    }
    catch (AggregateException aex)
    {
        Console.WriteLine($"异常数量：{aex.InnerExceptions.Count}");
    }
    catch (Exception ex)
    {
    
    }

使用 CancellationToken 取消其他Task或者自生

    var cts = new CancellationTokenSource();
    for (int i = 0; i < 20; i++)
    {
        var name = $"JOY_{i}";
        Task.Run(() =>
        {
            Console.WriteLine($"任务 {name} 开始。");
            try
            {
                if (name.Equals("JOY_6"))
                    throw new Exception("JOY_6异常");
    
                if (cts.IsCancellationRequested)
                    DoSomething(name, 2000);
                else
                    Console.WriteLine($"任务 {name} 取消。");
            }
            catch (Exception)
            {
                cts.Cancel();
            }
        // 将CancellationToken作为Task.Run的第二个参数，
        // 使得如果线程还没有启动，被取消就不执行任务
        }, cts.Token);
    }

五、使用Parallel开启多线程

Parallel 并发执行多个Action，主线程也会参与计算，会阻塞界面

等于 TaskWaitAll + 主线程计算

    Parallel.Invoke(
        () => DoSomething("JOY_1", 2000),
        () => DoSomething("JOY_2", 2000),
        () => DoSomething("JOY_3", 2000)
    );

Parallel 的 For 循环

同样主线程也会参与计算，会阻塞界面

	Parallel.For(0, 5, i => DoSomething($"JOY_{i}", 2000));

Parallel 的 ForEach 循环

同样主线程也会参与计算，会阻塞界面

	Parallel.ForEach(new int[] { 1, 2, 3, 4, 5 }, i => DoSomething($"JOY_{i}", 2000));

Parallel 控制并发数量

    Parallel.Invoke(
        options,
        () => DoSomething("JOY_1", 2000),
        () => DoSomething("JOY_2", 2000),
        () => DoSomething("JOY_3", 2000),
        () => DoSomething("JOY_4", 2000),
        () => DoSomething("JOY_5", 2000),
        () => DoSomething("JOY_6", 2000)
    );
    Parallel.For(0, 9, options, i => DoSomething($"JOY_{i}", 1000));
    Parallel.ForEach(
        new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
        options,
        i => DoSomething($"JOY_{i}", 2000)
        );

原文链接：https://blog.csdn.net/Upgrader/article/details/107774139

目录

前言：

一、使用委托开启多线程

二、使用Thread开启多线程

三、使用ThreadPool开启多线程

四、使用Task开启多线程

五、使用Parallel开启多线程

你可能也喜欢