.NET Core多线程 (1) Thread与Task

.NET Core多线程 (1) Thread与Task
合集：.NET Core多线程温故知新
- .NET Core多线程（1）Thread与Task
- .NET Core多线程（2）异步 - 上
- .NET Core多线程（3）异步 - 下
- .NET Core多线程（4）锁机制
- .NET Core多线程（5）常见性能问题
去年换工作时系统复习了一下.NET Core多线程相关专题，学习了一线码农老哥的《.NET 5多线程编程实战》课程，我将复习的知识进行了总结形成本专题。同时也特别推荐有兴趣的读者去学习一线码农老哥的《.NET 5多线程编程》课程。

本篇，我们来复习一下Thread与Task的相关知识点，预计阅读时间10分钟。

从时间和空间角度理解线程的开销

（1）多线程的优点
- 提高响应能力
- 提高程序性能
（2）线程有哪些开销
- 空间上的开销
- 时间上的开销
（3）总结

线程不是越多越好，线程有时间和空间上的开销，所以我们需要省着用。

线程的常用方法及生命周期管理

（1）Thread的基本操作
- Start
- Join
- Sleep
- IsBackground属性
（2）对Thread的思考

现在实际开发中直接用thread的不多，因为它较为底层，很多程序员用不好。
- 线程太多，造成上下文切换频繁（CPU暴高）
- GC负担过大，徒增GC负担
（3）一些解决方案
- ThreadPool：线程池
- Task：基于ThreadPool的上层封装
线程池的使用及分析其设计思想

（1）为什么要使用线程池？
- GC负担
- 上下文切换
让thread得到更好的使用，提高利用率，减少不必要的创建和销毁。

（2）线程池的基本使用
- 无参数
- object参数
- 泛型参数
- 其他方法
（3）ThreadPool的设计
- WinDbg视角下的ThreadPool
- ThreadPool的设计图如下：
在老版本的.NET Framework时代，只有一个全局队列，存在大量的锁竞争。

.NET Core中加入了本地队列，加入了本地队列，降低了锁竞争，并提高了线程的利用率。

具体实现思路是：

（1）每个线程优先从本地队列中取任务干活；

（2）如果本地队列中没有任务了，就从全局队列中取任务干活；

（3）当全局任务队列里面的任务没有的时候，CLR将会把其他有任务的线程中的未处理任务（比如上图中的WorkItem3），分配给这些空闲的线程（比如上图中的Thread3）去执行。这个机制也被称之为偷窃机制。

这样做的其目的是每个线程都有事干，即提高线程池中的线程利用率。

Task及如何运用其编排能力

（1）Task的设计思想

为什么会出现Task：
- 获取Thread的返回值比较麻烦
- 多个Thread的串行实现比较麻烦
- Thread的父子关系实现比较麻烦（比如：所有的子Thread执行完后，才能结束父Thread）
本质问题：如何高效地对Thread进行编排？

本质理解：Task就是一个Thread的编排工具，它解决了任务之间如何串行、如何并行、如何嵌套、如何父子等关系的处理，让程序员可以重点关注任务，而不是Thread。

（2）Task的基本使用

方式一：new Task，不推荐使用
```
// 无参数
var task = new Task(()=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}");
});
task.Start();
// 有参
var task = new Task((obj)=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}, Current Content={obj}");
}, "Hello World");
task.Start()
```
方式二：Task.Factory.StartNew
```
// 无参数
var task = Task.Factory.StartNew(()=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}");
});
// 有参
var task = Task.Factory.StartNew((obj)=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}, Current Content={obj}");
}, "Hello World");
```
方式三：Task.Run
```
// 无参数
var task = Task.Run(()=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}");
});
// 有参
var task = Task.Run((obj)=>
{
    Console.WriteLine($"Current ThreadId={Environment.CurrentManagedThreadId}, Current Content={obj}");
}, "Hello World");
```
Task串行、父子、并行等玩法

（1）串行玩法
```
var task1 = Task.Factory.StartNew(()=>
{
    new Sheet1().WriteSheet();
}).ContinueWith(t =>
{
    new Sheet2().WriteSheet();
}).ContinueWith(t =>
{
    new Sheet0().WriteSheet();
});
task1.Wait();
```
（2）并行+串行玩法
```
var sheets = new List { new Sheet1(), new Sheet2() };
var tasks = new Task[2];
for(int i=0; i)
{
    tasks[i] = Task.Factory.StartNew((index)=>
    {
        sheets[(int)index].WriteSheet();
    }, i);
}
Task.WhenAll(tasks).ContinueWith(t=>
{
    new Sheet[0].WriteSheet();
}).Wait();
```
（3）父子关系玩法

如果父Task中的任意一个子Task未完成，都不能继续。注意点：参数TaskCreationOptions.AttachedToParent
```
var sheets = new List { new Sheet1(), new Sheet2() };

//父task
var parent_task = Task.Factory.StartNew(() =>
{
    //1. 子task1
    var child_1_task = Task.Factory.StartNew(() =>
    {
        new Sheet1().WriteSheet();
    }, TaskCreationOptions.AttachedToParent);

    //2. 子task2
    var child_2_task = Task.Factory.StartNew(() =>
    {
        new Sheet2().WriteSheet();
    }, TaskCreationOptions.AttachedToParent);
});

var continueTask= parent_task.ContinueWith(t =>
{
    new Sheet0().WriteSheet();
});


Task.WhenAll(continueTask);
```
最后等待可以有几种写法：
```
continueTask.Wait();
Task.WaitAll(continueTask);
Task.WaitAny(continueTask);
```
以上三种会阻塞主线程。而下面这种方式不会阻塞主线程。
```
Task.WhenAll(continueTask);
```
解析：WaitAll/WaitAny方法阻塞了当前线程直到全完。WhenAll方法会开启个新监控线程去判读括号里的所有线程执行情况并立即返回，等都完成了就退出监控线程并返回监控数据。

任务取消CTS机制的使用

CTS = CancellationTokenSource，它主要是帮助开发者实现优雅退出（Graceful Exit）。

（1）没有CTS之前如何处理的

一是Thread.Abort()

二是增加临时变量如isStop来判断（hard cod）

（2）理解框架中的CTS使用
```
namespace EDT.MultiThread.Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            CTSDemo();
        }

        static void CTSDemo()
        {
            var source = new CancellationTokenSource();

            var task = Task.Factory.StartNew(() =>
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine($"当前线程:{Environment.CurrentManagedThreadId}, {DateTime.Now} 执行时间需要5s");

                    Thread.Sleep(1000);
                }
            }).ContinueWith(t =>
            {
                Console.WriteLine($"当前线程:{Environment.CurrentManagedThreadId}, 我是延续任务！");
            }, source.Token);

            Thread.Sleep(3000);
            source.Cancel();

            Console.WriteLine("主线程要取消你啦。。");
            Console.ReadLine();
        }

        /// 
        /// 业务方法
        /// 
        /// 
        static void Run(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                Thread.Sleep(1000);
                Console.WriteLine("1. 正在处理 redis 业务");

                Thread.Sleep(1000);
                Console.WriteLine("2. 正在处理 mongodb 业务");

                Thread.Sleep(1000);
                Console.WriteLine("3. 正在处理 sqlserver 业务");

                Thread.Sleep(1000);
                Console.WriteLine("4. 正在处理 mysql 业务");
            }
        }
    }
}
```
（3）其他功能
- 延迟取消 CancelAfter
- 注册取消通知 Register
任务调度机制及其自定义

（1）TaskScheduler是什么

TaskScheduler决定了将Task调度到什么地方去执行，即TaskScheduler决定了Task如何被调度。

（2）BCL中现存的TaskScheduler
- ThreadPoolTaskScheduler
- SynchronizationContextTaskScheduler
（3）自己实现一个TaskScheduler

自己实现一个单个Thread处理所有Task的TaskScheduler：
```
namespace EDT.MultiThread.Demo
{
    public class CustomTaskScheduler : TaskScheduler
    {
        Thread thread = null;

        BlockingCollection collection = new BlockingCollection();

        public CustomTaskScheduler()
        {
            thread = new Thread(() =>
            {
                foreach (var task in collection.GetConsumingEnumerable())
                {
                    TryExecuteTask(task);
                }
            });

            thread.Start();
        }

        protected override IEnumerable GetScheduledTasks()
        {
            return collection.ToArray();
        }

        protected override void QueueTask(Task task)
        {
            collection.Add(task);
        }

        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            throw new NotImplementedException();
        }
    }
}
```
调用端示例代码：
```
var scheduler = new CustomTaskScheduler();
for (int i = 0; i < 100; i++)
{
    var task = Task.Factory.StartNew(() =>
    {
        Console.WriteLine($"当前线程:{Environment.CurrentManagedThreadId}");
    }, CancellationToken.None, TaskCreationOptions.None, scheduler);
}

Console.ReadLine();
```
小结

本篇，我们复习了Thread与Task的基础知识。

下一篇，我们复习面试常考的重点-异步（async/await）相关知识。

参考资料

一线码农，腾讯课堂《.NET 5多线程编程实战》

不明作者，《Task调度与await》

作者：周旭龙

出处：https://edisonchou.cnblogs.com

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接。
相关阅读:
计算机网络概述
 AWS动手实验 - 在两层架构中部署 WordPress网站
 SpringSecurity——SG
数据库查询优化器，RBO优化规则介绍及示例
 简单博客网页
 Java代码审计之不安全的Java代码
 flume 对指定日志进行读取
 数据仓库的设计开发应用（三）
Go+VsCode配置环境
 基于ssm+vue的班级同学录网站管理系统 elementui
原文地址：https://www.cnblogs.com/edisonchou/p/dotnet_multithread_learning_notes_chap1.html

从时间和空间角度理解线程的开销

（1）多线程的优点

（2）线程有哪些开销

（3）总结

线程的常用方法及生命周期管理

（1）Thread的基本操作

（2）对Thread的思考

（3）一些解决方案

线程池的使用及分析其设计思想

（1）为什么要使用线程池？

（2）线程池的基本使用

（3）ThreadPool的设计

Task及如何运用其编排能力

（1）Task的设计思想

（2）Task的基本使用

Task串行、父子、并行等玩法

（1）串行玩法

（2）并行+串行玩法

（3）父子关系玩法

任务取消CTS机制的使用

（1）没有CTS之前如何处理的

（2）理解框架中的CTS使用

（3）其他功能

任务调度机制及其自定义

（1）TaskScheduler是什么

（2）BCL中现存的TaskScheduler

（3）自己实现一个TaskScheduler

小结

参考资料