第二节：深入剖析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 = 0;
            for (int i = 1; i < 999999999; 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 = 0;
            for (int i = 1; i < 999999999; 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 = 0;
            for (int i = 1; i < 999999999; 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 = 0; i < 5; 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 = 0;
                var t = new Thread(() =>
                {
                    var isSuccess = false;
                    while (isStop == 0)
                    {
                        Thread.VolatileRead(ref isStop);

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

                Thread.Sleep(1000);
                isStop = 1;

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


        }