多线程详解

1】挂起（suspend），就是我们说的暂停。挂起是用户主动发起的行为，所以，可以恢复。线程被挂起的时候，

CPU资源部不被释放。如果当前执行的任务优先级高，其他任务靠边站。挂起一般是程序调试中，为了观察某些数据，而使用。

方便调试。

【2】阻塞（pend），阻塞是一种被动的行为，但是任务会释放CPU，其他任务可以运行。阻塞一般是在等待某些资源或
信号量的时候出现。不确定什么时候恢复。

【3】Sleep（）和Wait（）都可以让程序等待多少毫秒。

Sleep（）方法没有是放锁。线程调用的时候，CPU资源一直占有。所以称为“占着CPU睡觉”。

Wait（）方法释放锁。其他线程可以使用资源。

sleep(2000)表示：占用CPU，程序休眠2秒。

wait(2000)表示：不占用CPU，程序等待2秒。

多线程的有点：

【1】计算机中一般会运行很多程序，会有很多对应的进程，进程的数量都会超过CPU的个数，如果所有的任务都通过进程来切换，会非常的耗时。

将每个进程，分成若干线程，通过线程切换代价更小。

【2】提升CPU的利用率。比如某些线程在等待资源的时候（等待输入、监听数据等）多线程允许其他线程继续执行，从而避免整个进程被阻塞。

从而提高了CPU的利用率。这就解释了，为什么有时候CPU的使用率很低，但是发现内存占用还很高的原因。

【3】在多CPU和多核情况下，真正实现并行运行。

多线程的缺点：

【1】线程越多，上下文切换的开销也越大。CPU的效率就会降低。

【2】线程间的同步容易出错，且不易调试。

【3】多线程是需要代价的。

========================================================================================

WinDbg的使用：底层内存查看工具，通过它可以观察CLR这一级别的信息，底层看的更清楚。

注意：请大家在使用我们提供的老版本的时候，需要手动添加符号文件，并且注意你项目的编译位数一定要和windbg的位数一致。

启动后，首先要载入.NET调试扩展包SOS ，是.NET框架的一部分，无需下来。

在操作系统对应目录中，请大家自己查看。
PS：sos所有的命令都以“！”开拓，通过!help查看所有的命令。

常用的命令：

【1】.loadby sos clr 加载sos.dll (以便支持更多的命令)

【2】!clrstack 打印当前线程调用的Stacktrace

【3】!dumpheap 打印堆中所有对象的地址，大小和方法表

主题：多线程原理研究*

目的：增加对线程空间和时间上的开销理解，才能更加合理的使用线程。

内容：
（1）线程Thread在内存空间上和时间的消耗研究
（2）线程Thread相关的实例方法
（3）线程Thread相关的静态方法

一、线程在内存空间上的开销是怎么样的？

【1】Thread内核数据结构：主要有osid（线程的ID）和Context（存放CPU寄存器相关的变量）

寄存器的状态会被随时的保存到Contex中，以便下次使用，多线程时间片切换中是有帮助。

时间片切换理解：计算机基于时间片把当前线程中的资源放到CPU的Context中，然后线程休眠，开始其他线程的调度。

一个时间片应该大约30ms左右（xp和vista时代）

【2】Thead环境块（Thread Environment Block，TEB）

包括：thread本地存储，exceptionList信息等。

0:007> .loadby sos clr
0:007> !threads
ThreadCount: 3
UnstartedThread: 0
BackgroundThread: 1
PendingThread: 0
DeadThread: 1
Hosted Runtime: no
Lock
ID OSID ThreadOBJ State GC Mode GC Alloc Context Domain Count Apt Exception
0 1 294c0 0000018436123130 2a020 Preemptive 0000018437BC7E38:0000018437BC7FD0 00000184360fa5c0 1 MTA
6 2 8454 000001843614d520 2b220 Preemptive 0000000000000000:0000000000000000 00000184360fa5c0 0 MTA (Finalizer)
XXXX 3 0 000001843617cf20 39820 Preemptive 0000000000000000:0000000000000000 00000184360fa5c0 0 Ukn

第1个线程是主线程
第2个线程是终结器（也就是GC用来回收资源的）
第3个线程是我们启动的。

以上内容都会占用资源，所以我们需要研究。

【3】用户堆栈模式：用户程序的“局部变量”和“参数传递”所使用的堆栈。

经常见到StackOverFlowException,内存溢出的基本原因其实就是《堆栈溢出》

默认情况：windows会分配1M的空间用于用户模式堆栈（换句话说，一个线程分配1M堆栈空间，主要用途参数，局部变量）

【4】内核堆栈模式：就是我们的程序要访问操作系统使用的堆栈。

理解：在CLR的线程操作的时候，通常最后会调用底层win32函数，用户模式中的参数需要传递到内核模式中。

---

二、线程在时间上的开销

【1】资源使用通知开销：我们运行一个程序，通常会加载很多托管的和非托管的dll，exe，资源，元数据…，我们通过windbg可以观察到。

使用windbg加载一个进程的时候，会有很多ModLoad列表，这些就是加载的模块…请在windbg上看那个进程列表…

这些dll有的是托管的，也有的是非托管的。

思考：程序运行的时候，如何查看应用程序域？

《常用命令3》!DumpDomain 输入后看到3个应用程序域，这个是进程启动的时候，默认的。

（1）System Domain: 系统程序域（由CLR创建的）

（2）Shared Domain: 共享程序域，加载了一个叫做mscorlib.dll模块，这个是系统模块，很多程序需要（如果感兴趣，可以自己研究）

 比如我们程序中用的那些int、long等都会放到这里面。

（3）Domain 1：加载了当前exe文件，还有mscorlib.dll模块，也就是我们运行的这个程序最终在这个里面。这个可以理解成私有的程序域。

开启一个Thread，销毁一个Thread，都会通知进程中的相关dll。通过相关的attach、detach等标志位。目的就是为了给线程做资源清理。

【2】时间片切换开销：

打开电脑的任务管理器，看CPU个数。

通过观察，当前我的计算机是4核四线程，如果超过4个线程，比如5个，必然会有一个thread休眠30ms，也就是时间片切换，来实现调度。

以上是我们开启一个线程，所带来的开销，请大家权衡后，适当的开启我们需要的线程，不要任意开启，否则CPU也难以承受。

我们看到的CPU中线程很多。但是本质上会有很多线程都是休眠的。CPU使用很低。

三、线程Thread相关的实例方法

我们主要研究Thread生命周期管理？需要首先了解几个方法：

Start，Suspend（暂停），Resume（恢复）、Interrupt（中断）、Abort（取消）

Join（不是生命周期管理的）

创建一个windows应用程序，测试一下：

【1】Start启动线程，从窗体上输出数据

【2】Suspend暂后，使用windbg观察thread状态

0:011> .loadby sos clr
0:011> !threads
ThreadCount: 3
UnstartedThread: 0
BackgroundThread: 1
PendingThread: 0
DeadThread: 0
Hosted Runtime: no
Lock
ID OSID ThreadOBJ State GC Mode GC Alloc Context Domain Count Apt Exception
0 1 3d10 0000000000e1fd00 26020 Preemptive 0000000002CDCCB0:0000000002CDDFD0 0000000000e133d0 0 STA
5 2 1efc 0000000000e4ce20 2b220 Preemptive 0000000000000000:0000000000000000 0000000000e133d0 0 MTA (Finalizer)
10 3 5d8 000000001cd73660 ab024 Preemptive 0000000002C9A7B0:0000000002C9BFD0 0000000000e133d0 0 MTA

0:011> !ThreadState ab024
User Suspend Pending （用户暂停模式）
Legal to Join
CLR Owns
CoInitialized
In Multi Threaded Apartment
Fully initialized
Sync Suspended （同步暂停）

接下来，我们输入qd，退出windbg，然后我们Resume

【3】Resume 继续：主要用来恢复Suspend的暂停功能。

【4】Interrupt 中断：会抛出异常。类似于C#中continue,中断后，会丢弃一个数字。看窗体输出效果。

【5】Abort 终止：通过抛出异常的方式销毁一个线程。非常类似于C#循环中的break

通过windbg观察 中断 和 终止的效果：

0:014> .loadby sos clr
0:014> !threads
ThreadCount: 3
UnstartedThread: 0
BackgroundThread: 1
PendingThread: 0
DeadThread: 1 死掉的一个线程 第3个线程的osid已经没有了，说明销毁了。
Hosted Runtime: no
Lock
ID OSID ThreadOBJ State GC Mode GC Alloc Context Domain Count Apt Exception
0 1 4f18 0000000001489f40 26020 Preemptive 00000000032BDA68:00000000032BDFD0 000000000147eb60 0 STA
5 2 2d8 00000000014b77c0 2b220 Preemptive 0000000000000000:0000000000000000 000000000147eb60 0 MTA (Finalizer)
XXXX 3 0 000000001f455ff0 839820 Preemptive 0000000000000000:0000000000000000 000000000147eb60 0 Ukn

继续观察第3个线程的状态：

0:014> !threadstate 839820
Legal to Join
Dead 当前线程已经over
CLR Owns
In Multi Threaded Apartment
Reported Dead
Fully initialized
Aborted 当前的状态

PS：Join：调用线程等待子线程执行完后才能执行（在此等待子线程执行完）

==============================================================================================================================

多线程原理研究（2）**

（1）Thread静态方法
（2）ThreadPool线程池

一、Thread中静态方法详解：

【1】数据槽：使用数据槽是为了解决多线程情况下，“共享资源”的竞用问题。也就是说讲数据存放到线程的环境块中，使得该数据

只能被单一的线程访问。（属于线程空间的开销）

MSDN对数据槽的解释，打开网址：
https://msdn.microsoft.com/zh-cn/library/vs/alm/6sby1byh(v=vs.100)

第一，使用《 Thread.AllocateDataSlot（）未命名的数据槽位》和《Thread.AllocateNamedDataSlot 命名的数据槽位》解决资源竞用。

static void Method1()
{
var myslot = Thread.AllocateNamedDataSlot(“mydata”);

        //主线程上设置槽位， 也就是数据只能被主线程读取，其他线程无法读取。使用SetData（）方法配合赋值：
        Thread.SetData(myslot, "喜科堂常老师讲解C#多线程");

        var childThread = new Thread(() =>
        {
            var data = Thread.GetData(myslot);//读取主线程中数据槽的数据，得不到的！
            Console.WriteLine($"当前子线程childThread读取数据的数据：{data }");
        });
        childThread.Start();

        var mainData= Thread.GetData(myslot);

        Console.WriteLine($"主线程上读取数据：{mainData}");

}
//未命名操作，请直接参考代码。

第二、《性能改进方法》

在主线程中使用 ThreadStatic特性标注在变量上面，则只有主线程有权访问该变量。

    [ThreadStatic]
    static string mainData= string.Empty;

    static void Method3()
    {
        mainData = "C#-Thread！";//观察在主线程上赋值会如何（工作线程没有数据）

        var childThread= new Thread(() =>
        {
            Console.WriteLine($"当前子线程childThread读取数据的数据：{mainData }");
        });
        childThread.Start();

       Console.WriteLine($"主线程上读取数据：{mainData}");
    }

第三，其他实现形式：ThreadLocal线程的本地存储（TLS： thread local storage），解决资源竞用问题

static void Method4()
{
ThreadLocal mainlocal = new ThreadLocal(); //观察这个ThreadLocald的帮助提示
mainlocal .Value = “我们正在研究多线程！”;

        var childThread = new Thread(() =>
        {
            Console.WriteLine($"当前子线程childThread读取数据的数据：{mainlocal.Value}");
        });
        childThread.Start();

         Console.WriteLine($"主线程上读取数据：{mainlocal.Value}");
    }

Q：以上是存放在哪里？
这些数据都是存放在线程环境块中…【是线程的空间开销】通过 !teb来查看,发现下面的内容

.loadby sos clr !threads 发现当前线程死掉。
!teb 发现Tls Storage 线程本地存储，在线程的环境块中
0:006> !teb
TEB at 0000009640b0b000
ExceptionList: 0000000000000000
StackBase: 0000009641200000
StackLimit: 00000096411fc000
SubSystemTib: 0000000000000000
FiberData: 0000000000001e00
ArbitraryUserPointer: 0000000000000000
Self: 0000009640b0b000
EnvironmentPointer: 0000000000000000
ClientId: 0000000000002b88 . 0000000000000df0
RpcHandle: 0000000000000000
Tls Storage: 0000000000000000
PEB Address: 0000009640afc000
LastErrorValue: 0
LastStatusValue: 0
Count Owned Locks: 0

!dumpstack 观察他的堆栈信息。了解即可。

---

二、thread中一些其他的静态方法

1、【在VS中用Thread测试下面的方法】观察他们的注释定义

【1】MemoryBarrier 【内存栅栏（屏障）】

【3】VolatileRead/Write 【易变读写】

Q：以上这些方法的用途是什么？

在实际项目中，我们一般都用Release版本，而不是Debug发布。因为Release中做了一些代码和缓存的优化,

比如说将一些数据从memory中读取到cpu高速缓存中。我们观察一下CPU任务管理器中，L1、L2、L3缓存，速度远高于内存。

2、比较release和debug后的程序在运行中的性能差异如何

【编写冒泡排序程序，并测试10次，比较Release和Debug】
先生成Debug，然后再生成Realease 直接运行生成的exe文件或者直接在工栏中运行，观察如下结果：

Debug的结果
第0次： 1345
第1次： 414
第2次： 399
第3次： 419
第4次： 408
第5次： 420
第6次： 399
第7次： 455
第8次： 393
第9次： 407
第10次：412

Release的结果
第0次： 440
第1次： 149
第2次： 125
第3次： 145
第4次： 135
第5次： 158
第6次： 135
第7次： 108
第8次： 111
第9次： 109
第10次：112

从结果中可以看到，大概有2-3倍的差距！release做了性能提升！

但是在任何时候，不见得release总是好的，有可能会给你引入一些bug。观察下面的程序

    static void Method2()
    {
        bool stop = false;//主线程定义一个变量（如果是用Release，会将stop变量放到CPU的Cache中）

        Thread thread = new Thread(() =>
        {
            int a = 0;
            while (!stop)     //子线程访问主线程的变量
            {
                a++;      
            }
        });
        thread.Start();
        thread.IsBackground = false;

        Thread.Sleep(1000);

        stop = true;//主线程也在使用stop变量，按照道理，这个地方修改成true以后，子线程的循环应该执行结束。

        thread.Join();//等待子线程结束

        Console.WriteLine("主线程执行结束！");
    }

上面这段代码在release环境下出现问题了：主线程不能执行结束。

【问题分析】

从代码中可以发现，有两个线程在共同一个stop变量。

就是thread这个线程会将stop加载到Cpu Cache中，而主线程中，又修改了stop的数据，所以thread是无法知道的，

这样while就会一直执行！而主线程又在Join子线程，所以，无法输出！

【注意问题】以上情况，不是绝对的，也就是说主线程和子线程公用变量的情况，是否会出现上面的情况，是不完全确定的。

通常的解决方法：

【1】 不要让多个线程去操作一个共享变量，否则容易出问题。从根本上解决问题。

【2】如果一定要这么做，那就需要使用本节课所讲到的两个方法：

MemoryBarrier（）
VolatileRead/Write（）

也就是：不要进行缓存，每次读取数据都是从memory中读取数据。就不存在上面的问题。

【解决方法1：使用 Thread.MemoryBarrier()】
MemoryBarrier => 在此方法之前的内存写入都要及时从cpu cache中更新到 memory。

                         在此方法之后的内存读取都要从memory中读取，而不是cpu cache。


    static void Method3()
    {         
        bool stop = false;  
                
        Thread thread = new Thread(() =>
        {
            int a = 0;
            while (!stop)  
            {
                //在此方法之前的内存写入都要及时从cpu cache中更新到 memory。
                //在此方法之后的内存读取都要从memory中读取，而不是cpu cache。
                Thread.MemoryBarrier();
                a++;                        
            }
        });
        thread.Start();
        thread.IsBackground = false;

        Thread.Sleep(1000);
        stop = true;
        thread.Join();
        Console.WriteLine("主线程执行结束！");
        Console.ReadLine();
    }

【解决方法2：使用 Thread.VolatileRead()】
static void Method4()
{
int stop = 0;

        Thread thread = new Thread(() =>
        {
            int a = 0;
            while (stop == 0)
            {
                Thread.VolatileRead(ref stop);//写入的最新值，就是memory中的最新值
                a++;
            }
        });
        thread.Start();
        thread.IsBackground = false;

        Thread.Sleep(1000);
        stop = 1;
        thread.Join();
        Console.WriteLine("主线程执行结束！");
    }

---

前面：Thread和ThreadPool

【1】Thread：只要我们需要异步任务，都会开启一个Thread，比然有时间和空间开销。

【2】TheadPool：是一个线程池，由系统维护和缓存，因为默认都是初始化好的，所以使用方便，退回容易。用的时候，只需要请求即可。

我们通过普通的Thread开启10个线程，得到结果：

0:006> .loadby sos clr
0:006> !threads
ThreadCount: 12
UnstartedThread: 0
BackgroundThread: 1
PendingThread: 0
DeadThread: 10
Hosted Runtime: no
Lock
ID OSID ThreadOBJ State GC Mode GC Alloc Context Domain Count Apt Exception
0 1 4704 0000028a442cc8b0 2a020 Preemptive 0000028A45FD7B58:0000028A45FD7FD0 0000028a442a33e0 1 MTA
5 2 4374 0000028a442f6450 2b220 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 MTA (Finalizer)
XXXX 3 0 0000028a44322ba0 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 4 0 0000028a44341e20 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 5 0 0000028a44342ad0 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 6 0 0000028a44343990 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 7 0 0000028a44344850 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 8 0 0000028a44345710 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 9 0 0000028a443465d0 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 10 0 0000028a44347490 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 11 0 0000028a44348350 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn
XXXX 12 0 0000028a4434b010 39820 Preemptive 0000000000000000:0000000000000000 0000028a442a33e0 0 Ukn

总结：主线程和终结器线程各1个。10个DeadThread,但是没有被GC回收。

通过ILSpy观察线程销毁

~Thread()
{
this.InternalFinalize(); 就是进入终结器，按照CLR的机制，进入终结器，后面还有可能被激活，如果没有，下次会被GC回收。
}

通过线程池开启10个任务

我们观察
0:010> .loadby sos clr
0:010> !threads
ThreadCount: 6
UnstartedThread: 0
BackgroundThread: 5
PendingThread: 0
DeadThread: 0
Hosted Runtime: no
Lock
ID OSID ThreadOBJ State GC Mode GC Alloc Context Domain Count Apt Exception
0 1 4a04 00000253280db480 2a020 Preemptive 0000025329E4E358:0000025329E4FFD0 00000253280b1800 1 MTA
5 2 254 0000025328105010 2b220 Preemptive 0000000000000000:0000000000000000 00000253280b1800 0 MTA (Finalizer)
6 3 2ea4 000002532813e910 1029220 Preemptive 0000025329E4C8B0:0000025329E4DFD0 00000253280b1800 0 MTA (Threadpool Worker)
7 4 2c14 000002532813fbf0 1029220 Preemptive 0000025329E48E30:0000025329E49FD0 00000253280b1800 0 MTA (Threadpool Worker)
8 5 3298 0000025328140f30 1029220 Preemptive 0000025329E4A8B0:0000025329E4BFD0 00000253280b1800 0 MTA (Threadpool Worker)
9 6 5e0 00000253281465a0 1029220 Preemptive 0000025329E50710:0000025329E51FD0 00000253280b1800 0 MTA (Threadpool Worker)

总结：
现在有4个工作线程，并且都是活的。因为我的电脑是4核心4线程。我们可以自行设定大小，但是不建议。
ThreadPool.SetMinThreads(10,100)

---

总结：
【1】我们的线程池可以根据电脑的实际CPU情况开启一定个数的线程，放到线程池中。
【2】10个异步任务，但是我们通过4个线程就完成了。节省时间和空间开销。

通过线程池做一些扩展（定时器类）