C#线程--5.0之前时代(一)--- 原理和基本使用

一、开篇概念明晰：

多任务：

协作式多任务：cpu可以处理多种任务，但是这些任务是排队等候的，当cpu在处理一个任务的时候，其他的任务被锁定，只有当cpu处理完当前任务，才可以继续处理下一个任务（专一暖男）；
抢占式多任务：一个任务正在执行，可以被强行中断挂起，去执行其他的任务（花心大萝卜）。

进程与线程：

进程：内存和资源的物理分离成为进程。分配给进程的内存只有所属的进程才可以访问。一个应用程序可以启动多个进程
线程：开发架构将程序中的一部分进行分离，使被分离的部分与程序的其余部分执行顺序不一致的操作。（在计算机中，程序的运行时由程序计数器决定的，程序计数器就像是一个指针，指定了应用程序下一步需要执行的指令。）
进程与线程：一个进程启动，默认会有一个主线程，但是一个进程可以对应多个线程。
时间片：处理器分配给线程的执行时间。一个处理器一次只能处理一个线程，所谓的多任务（抢占式）就是处理器在快速切换执行不同的线程。若是有多个处理器就不一样了。（自我入宫以来以为可以独得皇上宠爱，没想到皇上要雨露均沾）。

中断：

前置知识点：

1、进程是内存和资源的物理分离，只有所属线程才能访问；

2、一个cpu给一次只能执行一个线程，cpu给每一个线程分配时间片，多线程就是在不同线程之间快速切换。

问题：进程间相互独立且不可访问，那么，cpu是怎么进行线程切换的，也就是问:一个线程正在执行，它要怎么知道要中断挂起，给其他线程来执行。

答案：Windows本身（其实也是处理器上正在运行的一个程序）有一个主线程----系统线程，负责其他线程的调度。

线程本地存储器（Thread Local Storage,TLS）：存储线程的状态信息。当一个线程执行的时间片到期的时候，需要存储下线程当前的状态信息，以确保在他被分配的下一个时间片可以正常的执行。TLS包含了：

寄存器、堆栈指针、调度信息、内存中的地址空间和其他资源的使用信息。

其中寄存器中有一个是程序计数器，存放了线程接下来应该执行的指令。（CPU执行的指令的都是从寄存器读取的）

中断：中断是一种机制，它能够使CPU指令的正常顺序执行转向计算机内存中的其他地方，而不需要知道目前正在执行什么程序。解释如下：

1、程序要开始执行一个线程之前：系统线程先决定线程要执行多长时间，and在当前线程的执行序列中放置一条中断指令。疑问：不确定这个指令是在时间片到了之后插入的还是在线程开始之前预先插入的，但推测是等待时间片要到的时候插入的，因为程序执行的指令并不是容易预测的，不同的数据不同走不同的逻辑分支，程序的执行是一边编一边走的（会先编译的快一些）而不是编译好所有的逻辑分支的指令，等待程序执行的时候根据数据进行选择，所以个人觉得很难预测要走哪一个逻辑分支，很难提前太早插入中断指令。

2、程序开始执行一个线程：读取TLS中线程的程序计数器，把该程序计数器的指令指向的地址从TLS中拖拽出来插入到CPU执行的指令集合中，同时把TLS中的堆栈信息加载到CPU的其他寄存器中。线程开始执行

3、当碰到中断指令时：存储当前线程的堆栈信息，记录当前线程的程序计数器数据，记录其他资源的信息，存储入TLS,把当前线程放入线程队列的末尾，返回到线程队列的开头准备执行队列的第一个线程，回到步骤1。

线程睡眠：线程退出执行队列一段时间称为睡眠。有时一个线程的执行需要一定的资源，但是当线程开始执行时，这个资源并没有生成或者正在被使用，因此线程需要等待一段时间。

时钟中断：一个线程进入睡眠是它会再次被打包放入TLS中，不过并不是放置在了TLS的末尾，而是放入了一个独立的睡眠队列中，为了时睡眠队列上的线程再次运行，需要使用另一种中断了标记他们，成为时钟中断。当一个睡眠的线程可以执行的时候，它才会被放入到可运行的线程队列中，的末尾。

线程终止：

线程执行结束，线程终止；
在执行另外一个线程的过程中，用一个请求显示的停止线程。

线程终止时，线程的TLS会释放其内存。

二、线程的创建：
直接贴代码：

1、创建线程：

2、使用线程创建线程：

        public override void DoExecute()
        {
            base.DoExecute();
            Thread mainThread = new Thread(new ThreadStart(MainThread));
            AddLog("current main thread's state is " + mainThread.ThreadState);
            mainThread.Start();
            AddLog("current main thread's state is " + mainThread.ThreadState);
        }


        private void FirstThread()
        {
            AddLog("FirstThread start~");
            for (int i = 0; i < 100; i++)
            {
                AddLog("FirstThread index~ "+i);
            }

            AddLog("FirstThread stop~");
        }


        private void ThecondThread()
        {
            AddLog("ThecondThread start~");

            for (int i = 100; i < 200; i++)
            {
                AddLog("ThecondThread index~ " + i);
            }

            AddLog("ThecondThread stop~");
        }

        private void MainThread()
        {
            AddLog("MainThread start~");

            Thread firstThread = new Thread(new ThreadStart(FirstThread));
            Thread secondThread = new Thread(new ThreadStart(ThecondThread));
            firstThread.Start();
            secondThread.Start();
            
            for (int i = 0; i < 100000; i++)
            {

            }

            AddLog("thecondThread state " + secondThread.ThreadState);
            AddLog("MainThread stop~");
        }

3、线程的睡眠和恢复：

使用属性：

ThreadState：ThreadState是一个枚举类型，表示线程的当前状态，当线程睡眠的时候线程状态值为ThreadState.WaitSleepJoin;

注意一个类似的属性：IsAlive （获取指示当前线程的执行状态的值）如果此线程已经开始但尚未正常终止或中止，则为 true，否则为 false。所以当线程睡眠的时候，isAlive仍然为true；

使用方法:

Sleep(int millisecondsTimeout); millisecondsTimeout表示使线程睡眠的毫秒数；
Interrupt(); 中断处于 WaitSleepJoin 线程状态的线程。

测试代码：

        public static void SleepThread()
        {
            Thread newThread = new Thread(new ThreadStart(PrintNo));
            newThread.Name = "new thread";
            newThread.Start();

            while (true)
            {
                if (newThread.ThreadState == ThreadState.WaitSleepJoin)
                {
                    Console.WriteLine("current thread state: " + newThread.ThreadState);
                    newThread.Interrupt();
                    break;
                }
            }
        }

        static void PrintNo()
        {
            for (int i = 0; i < 99; i++)
            {
                Console.WriteLine("print " + i);
                if (i == 90)
                {
　　　　　　　　　　　　//
                    try 
                    {
                        Thread.Sleep(2000);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("new thread interrupted"+ex.Message);
                    }
                    Console.WriteLine("current thread is " + Thread.CurrentThread.Name + ", state: " + Thread.CurrentThread.ThreadState);
                }
            }
        }

结果：

...
print 81
print 82
print 83
print 84
print 85
print 86
print 87
print 88
print 89
print 90
current thread state: WaitSleepJoin
new thread interrupted
current thread is new thread, state: Running
print 91
print 92
print 93
print 94
print 95
print 96
print 97
print 98

Interrupt() 是对睡眠的线程提前唤醒的最好方法，需要注意的是使用这个方法会抛出异常需要捕获。

4、线程的中止(终止)和取消中止（终止）:

使用方法：

Thread.CurrentThread.Abort(); 终止当前线程 --- 调用该方法线程将进入正在终止状态 ------ AbortRequested，
Thread.ResetAbort(); 取消当前线程Abort的请求使线程继续执行。调用该方法线程将恢复

        public static void AbortThread()
        {
            Thread newThread = new Thread(new ThreadStart(PrintNo));
            newThread.Name = "new thread for abort";
            newThread.Start();
        }

        static void PrintNo()
        {
            for (int i = 0; i < 99; i++)
            {
                Console.WriteLine("print " + i);
                if (i == 90)
                {
                    try
                    {
                        Thread.CurrentThread.Abort(); // 中断当前线程，会引发异常
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("current thread is " + Thread.CurrentThread.Name + ", state: " + Thread.CurrentThread.ThreadState);

                        Console.WriteLine("new thread Aborted" + ex.Message);

                        // 取消当前线程请求的Abort();
                        //Thread.ResetAbort();
                    }
                    Console.WriteLine("current thread is " + Thread.CurrentThread.Name + ", state: " + Thread.CurrentThread.ThreadState);

                }
            }
        }

运行结果：

。。。
print 87
print 88
print 89
print 90
current thread is new thread for abort, state: AbortRequested
new thread Aborted正在中止线程。

如果取消上面对 Thread.ResetAbort(); 的注释，线程将不会终止，而是会继续执行。

5、使用join:
使用方法：join()，join是线程实例上的方法，当调用该方法的时候调用该方法的线程实例将进入WaitSleepJoin状态，直到当前线程执行完毕之后才开始继续执行线程实例所属的线程。
（我感觉理解起来有点绕，意思就是：有两个线程A和B,线程A需要在线程B之前执行，那么可以使用Join方法，在线程A内用线程B调用Join方法，这样可以使线程B进入WaitSleepJoin状态，线程A不变继续执行，当线程A执行完毕，B会开始执行。而如果有线程C,则线程C是不影响的）如下所示：

class ThreadTestForJoin
    {
        static Thread newThread;
        static Thread newThread2;
        static Thread newThread3;
        public static void JoinThread()
        {
            newThread = new Thread(new ThreadStart(PrintNo));
            newThread.Name = "new thread for join";
            newThread.Start();
            newThread2 = new Thread(new ThreadStart(PrintNo2));
            newThread2.Name = "new thread be joined";
            newThread2.Start();
            newThread3 = new Thread(new ThreadStart(PrintThreadThree));
            newThread3.Name = "我是勤劳的小画家";
            newThread3.Start();
        }

        static void PrintNo()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("print " + i);
            }
        }

        static void PrintNo2()
        {
            newThread.Join();
            for (int i = 100; i < 199; i++)
            {
                Console.WriteLine("print " + i);
            }
        }

        static void PrintThreadThree()
        {
            for (int i = 0; i < 200; i++)
            {
                Console.WriteLine("print " + Thread.CurrentThread.Name);
            }
        }
    }

运行结果：

。。。
print 我是勤劳的小画家
print 我是勤劳的小画家
print 我是勤劳的小画家
print 92
print 93
print 94
print 95
print 96
print 97
print 98
print 99
print 我是勤劳的小画家
print 我是勤劳的小画家
print 我是勤劳的小画家
print 我是勤劳的小画家
print 100
print 101
print 102
。。。