第二节：深入剖析Thread的五大方法、数据槽、内存栅栏。

一. Thread及其五大方法

　　Thread是.Net最早的多线程处理方式，它出现在.Net1.0时代，虽然现在已逐渐被微软所抛弃，微软强烈推荐使用Task(后面章节介绍)，但从多线程完整性的角度上来说，我们有必要了解下N年前多线程的是怎么处理的，以便体会.Net体系中多线程处理方式的进化。

　　Thread中有五大方法，分别是：Start、Suspend、Resume、Intterupt、Abort

　　①.Start：开启线程

　　②.Suspend：暂停线程

　　③.Resume：恢复暂停的线程

　　④.Intterupt：中断线程(会抛异常，提示线程中断)

　　⑤.Abort：销毁线程

　  这五大方法使用起来，也比较简单，下面贴一段代码，体会一下如何使用即可。

　　在这里补充一下，在该系列中，很多测试代码中看到TestThread0、TestThread、TestThread2，分别对应无参、一个参数、两个参数的耗时方法，代码如下：

   /// <summary>
         /// 执行动作:耗时而已
         /// </summary>
         private void TestThread0()
         {
             Console.WriteLine("线程开始：当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"));
             long sum = ;
             for (int i = ; i < ; i++)
             {
                 sum += i;
             }
             Console.WriteLine("线程结束：当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"));
         }

         /// <summary>
         /// 执行动作:耗时而已
         /// </summary>
         private void TestThread(string threadName)
         {
             Console.WriteLine("线程开始：线程名为：{2}，当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
             long sum = ;
             for (int i = ; i < ; i++)
             {
                 sum += i;
             }
             Console.WriteLine("线程结束：线程名为：{2}，当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
         }

         /// <summary>
         /// 执行动作:耗时而已
         /// </summary>
         private void TestThread2(string threadName1, string threadName2)
         {
             Console.WriteLine("线程开始：线程名为：{2}和{3}，当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName1, threadName2);
             long sum = ;
             for (int i = ; i < ; i++)
             {
                 sum += i;
             }
             Console.WriteLine("线程结束：线程名为：{2}和{3}，当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName1, threadName2);
         }

二. 从源码角度分析Thread类

(1)  分析Thread类的源码，发现其构造函数有两类，分别是ThreadStart和ParameterizedThreadStart类，

　其中

　　①：ThreadStart类，是无参无返回值的委托。

　　②：ParameterizedThreadStart类,是有一个object类型参数但无返回值的委托.

使用方法：

　　①：针对ThreadStart类， ThreadStart myTs = () => TestThread(name);  然后再把myTs传入Thread的构造函数中

　　②：针对ParameterizedThreadStart类，ParameterizedThreadStart myTs = o => this.TestThread(o.ToString());  然后再把myTs传入Thread的构造函数中

　　注：该方式存在拆箱和装箱的转换问题，不建议这么使用

通用写法：

　　　　Thread t = new Thread(() =>

　　　　{

　　　　　　Console.Write("333");

　　　　});

　　　　t.Start();

无须考虑Thread的构造函数,也不需要考虑Start的时候传参，直接使用()=>{}的形式，解决一切问题。

(二) 前台进程和后台进程（IsBackground属性）

　　①：前台进程,Thread默认为前台线程，程序关闭后，线程仍然继续，直到计算完为止

　　②：后台进程,将IsBackground属性设置为true，即为后台进程，主线程关闭，所有子线程无论运行完否，都马上关闭

(三) 线程等待（Join方法）

　　利用Join方法实现主线程等待子线程,当多个子线程进行等待的时候，只能通过for循环来实现

 下面贴一下这三块设计到的代码：

   private void button3_Click(object sender, EventArgs e)
         {
             Stopwatch watch = new Stopwatch();
             watch.Start();
             Console.WriteLine("-----------------Thread多线程  --------------------------");
             Console.WriteLine("----------------- button_Click 开始 主线程id为：{0}  --------------------------", Thread.CurrentThread.ManagedThreadId);
             List<Thread> threadList = new List<Thread>();
             for (int i = ; i < ; i++)
             {
                 string name = string.Format("button1_Click{0}", i);

                 #region 方式一
                 {
                     ThreadStart myTs = () => TestThread(name);
                     Thread myThread = new Thread(myTs);
                     //Thread默认为前台线程，程序关闭后，线程仍然继续，直到计算完为止
                     myThread.IsBackground = true;   //设置为后台线程，主程序关闭所有线程均关闭
                     myThread.Start();

                     threadList.Add(myThread);
                 }

                 #endregion

                 #region 方式二
                 //{
                 //    ParameterizedThreadStart myTs = o => this.TestThread(o.ToString());
                 //    //ParameterizedThreadStart myTs = (o) =>
                 //    //{
                 //    //    this.TestThread(o.ToString());
                 //    //};
                 //    Thread myThread = new Thread(myTs);
                 //    myThread.Start(name);

                 //    threadList.Add(myThread);
                 //}

                 #endregion
             }

             #region Thread线程等待

             //利用join方法进行线程等待
             foreach (Thread thread in threadList)
             {
                 thread.Join();
             }
             #endregion

             watch.Stop();
             Console.WriteLine("----------------- button_Click 结束 主线程id为：{0}  总耗时：{1}--------------------------", Thread.CurrentThread.ManagedThreadId, watch.ElapsedMilliseconds);

         }

(四). 扩展：Thread实现线程回调

三. 数据槽-线程可见性

　　背景：为了解决多线程竞用共享资源的问题，引入数据槽的概念，即将数据存放到线程的环境块中，使该数据只能单一线程访问.（属于线程空间上的开销）

　　下面的三种方式是解决多线程竞用共享资源的通用方式：

　　①：AllocateNamedDataSlot命名槽位和AllocateDataSlot未命名槽位 解决线程竞用资源共享问题。

　　(PS:在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问)

   private void button10_Click(object sender, EventArgs e)
        {
            #region 01-AllocateNamedDataSlot命名槽位
            {
                var d = Thread.AllocateNamedDataSlot("userName");
                //在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问
                Thread.SetData(d, "ypf");
                //声明一个子线程
                var t1 = new Thread(() =>
                {
                    Console.WriteLine("子线程中读取数据：{0}", Thread.GetData(d));
                });
                t1.Start();

                //主线程中读取数据
                Console.WriteLine("主线程中读取数据：{0}", Thread.GetData(d));
            }

            #endregion

            #region 02-AllocateDataSlot未命名槽位
            {
                var d = Thread.AllocateDataSlot();
                //在主线程上设置槽位，使该数据只能被主线程读取，其它线程无法访问
                Thread.SetData(d, "ypf");
                //声明一个子线程
                var t1 = new Thread(() =>
                {
                    Console.WriteLine("子线程中读取数据：{0}", Thread.GetData(d));
                });
                t1.Start();

                //主线程中读取数据
                Console.WriteLine("主线程中读取数据：{0}", Thread.GetData(d));

            }
            #endregion

        }

　　②：利用特性[ThreadStatic] 解决线程竞用资源共享问题

　　(PS:在主线程中给ThreadStatic特性标注的变量赋值，则只有主线程能访问该变量)

　　③：利用ThreadLocal线程的本地存储， 解决线程竞用资源共享问题（线程可见性）

　　(PS: 在主线程中声明ThreadLocal变量，并对其赋值，则只有主线程能访问该变量)

四. 内存栅栏-线程共享资源

背景：当多个线程共享一个变量的时候，在Release模式的优化下，子线程会将共享变量加载的cup Cache中，导致主线程不能使用该变量而无法运行。

解决方案：

　　①：不要让多线程去操作同一个共享变量,从根本上解决这个问题。

　　②：利用MemoryBarrier方法进行处理,在此方法之前的内存写入都要及时从cpu cache中更新到 memory；在此方法之后的内存读取都要从memory中读取，而不是cpu cache。

　　③：利用VolatileRead/Write方法进行处理。

  private void button11_Click(object sender, EventArgs e)
         {
             #region 01-默认情况(Release模式主线程不能正常运行)
             //{
             //    var isStop = false;
             //    var t = new Thread(() =>
             //    {
             //        var isSuccess = false;
             //        while (!isStop)
             //        {
             //            isSuccess = !isSuccess;
             //        }
             //        Console.WriteLine("子线程执行成功");
             //    });
             //    t.Start();

             //    Thread.Sleep(1000);
             //    isStop = true;

             //    t.Join();
             //    Console.WriteLine("主线程执行结束");
             //}
             #endregion

             #region 02-MemoryBarrier解决共享变量（Release模式下可以正常运行）
             //{
             //    var isStop = false;
             //    var t = new Thread(() =>
             //    {
             //        var isSuccess = false;
             //        while (!isStop)
             //        {
             //            Thread.MemoryBarrier();

             //            isSuccess = !isSuccess;
             //        }
             //        Console.WriteLine("子线程执行成功");
             //    });
             //    t.Start();

             //    Thread.Sleep(1000);
             //    isStop = true;

             //    t.Join();
             //    Console.WriteLine("主线程执行结束");
             //}
             #endregion

             #region 03-VolatileRead解决共享变量（Release模式下可以正常运行）
             {
                 var isStop = ;
                 var t = new Thread(() =>
                 {
                     var isSuccess = false;
                     while (isStop == )
                     {
                         Thread.VolatileRead(ref isStop);

                         isSuccess = !isSuccess;
                     }
                     Console.WriteLine("子线程执行成功");
                 });
                 t.Start();

                 Thread.Sleep();
                 isStop = ;

                 t.Join();
                 Console.WriteLine("主线程执行结束");
             }
             #endregion

         }