.net基础—多线程（二）

Thread

在.NET中最早提供的控制线程类型的类型：System.Threading.Thread类。使用该类型可以直观地创建、控制和结束线程。下面是一个简单的多线程程序：

static void Main(string[] args)
        {
            Console.WriteLine("进入多线程模式：");

            for (int i = 0; i < 5; i++)
            {
                Thread t = new Thread(Work);
                t.Start();//开启新线程
            }

            Console.ReadKey();
        }

        static void Work()
        {
            Console.WriteLine($"开始工作的线程ID：{Thread.CurrentThread.ManagedThreadId} ");
            Thread.Sleep(1000);//假如处理任务耗时1s
            Console.WriteLine($"结束工作的线程ID：{Thread.CurrentThread.ManagedThreadId} ");
        }

　该段代码是在主线程中创建5个线程，每个线程进行独立的工作互不干涉。代码执行结果如下：

Thread中提供了很多控制线程的方法，例如：终止本线程（Abort）、暂停（Suspend）、恢复（Resume）、阻塞调用线程（Join）等等。

ThreadPool

Thread是.NET Framework 1.0中推出实现多线程的方案，它是直接从计算机系统里抓取的线程，这就存在很多问题，例如：频繁的创建和销毁线程、无节制的创建线程等。所以微软在.NET Framework 2.0中推出ThreadPool（线程池），它是给开发人员提供一个线程容器，在使用多线程的时从容器中抓取线程。

internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("进入多线程模式：");

            for (int i = 0; i < 10; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(Work));
            }

            Console.ReadKey();
        }

        static void Work(object stateInfo)
        {
            Console.WriteLine($"开始工作的线程ID：{Thread.CurrentThread.ManagedThreadId} ");
            //
            Console.WriteLine($"结束工作的线程ID：{Thread.CurrentThread.ManagedThreadId} ");
        }

    }

上面这段就是使用ThreadPool实现多线程，代码执行结果如下：

Task

Task是从 .NET Framework 4 推出的实现多线程的方法，Task 的使用非常简单，一行代码就可以开始一个异步任务，代码如下：

        static void Main(string[] args)
        {
            Console.WriteLine($"Task 示例，当前线程的ID：{Thread.CurrentThread.ManagedThreadId}");
            Task.Run(() => Console.WriteLine($"Task 开启的线程，当前线程的ID：{Thread.CurrentThread.ManagedThreadId}"));
            Console.ReadKey();
        }

向新创建的Task中传递参数的示例代码：

static void Main(string[] args)
    {
        Console.WriteLine($"Task 示例，当前线程的ID：{Thread.CurrentThread.ManagedThreadId}");

            string temp = "Tanyongjun";

            Task t = new Task(obj => Console.WriteLine($"Task 开启的线程，传递进来的参数:{obj},当前线程的ID：{Thread.CurrentThread.ManagedThreadId}"), temp);
            t.Start();

        Console.ReadKey();
    }

返回一个 int 类型结果的示例代码：

static void Main(string[] args)
        {
            Console.WriteLine($"Task 示例，当前线程的ID：{Thread.CurrentThread.ManagedThreadId}");

            Task<int> t = new Task<int>(() => {
                int sum = 0;
                for (int i = 0; i < 10; i++)
                {
                    sum += i;
                }
                return sum;
            });
            t.Start();
            Console.WriteLine($"使用Task开启新线程计算的结果：{t.Result}");

            Console.ReadKey();
        }

使用 TaskFactory 开始异步任务

static void Main(string[] args)
        {
            List<Task<int>> tasks = new List<Task<int>>();
            TaskFactory factory = new TaskFactory();
            tasks.Add(factory.StartNew<int>(() => { return 123; }));
            tasks.Add(factory.StartNew<int>(() => { return 456; }));
            foreach (var item in tasks)
            {
                Console.WriteLine($"返回值：{item.Result}");
            }

            Console.Read();
        }

上面的代码使用 TaskFactory 创建并运行了两个异步任务，同时把这两个任务加入了任务列表 tasks 中，然后使用foreach遍历出执行的结果。代码执行效果如下：

用Task来模拟一个项目开发的场景

        static void Main(string[] args)
        {

            Console.WriteLine($"项目经理启动一个项目。线程ID：{Thread.CurrentThread.ManagedThreadId} ");
            Console.WriteLine($"前期准备工作。线程ID：{Thread.CurrentThread.ManagedThreadId} ");
            Console.WriteLine($"开始编程。线程ID：{Thread.CurrentThread.ManagedThreadId} ");

            List<Task> tasks = new List<Task>();//存放新开启的Task
            tasks.Add(Task.Run(() => Coding("张三", "后端")));
            tasks.Add(Task.Run(() => Coding("李四", "前端")));
            tasks.Add(Task.Run(() => Coding("王五", "测试")));

            // 阻塞当前线程，等着某一个任务执行完成后，才进入下一行。
            Task.WaitAny(tasks.ToArray());
            Console.WriteLine($"************** 项目里程碑。。线程ID：{Thread.CurrentThread.ManagedThreadId} **************");

            //等待1秒之后，执行某个动作
            //Task.WaitAll(tasks.ToArray(), 1000);
            //Console.WriteLine($"************** 已经等待了1秒啦。。线程ID：{Thread.CurrentThread.ManagedThreadId} **************");

            // 阻塞当前线程，等着全部任务完成后，才进行下一行。
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine($"部署到正式环境，上线使用。线程ID：{Thread.CurrentThread.ManagedThreadId} ");

            Console.Read();
        }

        private static void Coding(string name, string project)
        {
            Console.WriteLine($"Coding {name} 开始 {project}。线程ID：{Thread.CurrentThread.ManagedThreadId}。");
            int temp = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                temp += i;
            }
            Console.WriteLine($"Coding {name} 结束 {project}。线程ID：{Thread.CurrentThread.ManagedThreadId}。");

        }

代码执行效果如下：

Task 内部提供多种多样的基于队列的链式任务管理方法，通过使用这些快捷方式，可以让异步队列有序的执行，例如：ContinueWith()，ContinueWhenAll()，ContinueWhenAny(),WaitAll()，WaitAny()，WhenAll(),WhenAny()。

线程中的异常处理

static void Main(string[] args)
        {
            try
            {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 5; i++)
                {
                    int k = i;
                    Action<object> act = t => {
                        Thread.Sleep(1000);
                        if (k == 3)
                            throw new Exception("出现异常啦！");
                        Console.WriteLine($"程序正常 -- {k}。");
                    };
                    taskList.Add(taskFactory.StartNew(act, k));
                }
            }
            catch (AggregateException aex)
            {
                foreach (var item in aex.InnerExceptions)
                {
                    Console.WriteLine(item.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }

　　上面的代码执行结果：

在vs调试的时候能看到出现异常，但在从执行结果上看不到异常信息。这是因为线程里面的异常是抓不到的，它已经脱离try/catch 的范围。所以在新的线程内部添加try/catch ,也就是Action 具体操作内容加上try/catch，让Action不会出现异常。

上面的代码改动如下：

static void Main(string[] args)
        {
            try
            {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 5; i++)
                {
                    int k = i;
                    Action<object> act = t => {
                        try
                        {
                            Thread.Sleep(1000);
                            if (k == 3)
                                throw new Exception("出现异常啦！");
                            Console.WriteLine($"程序正常 -- {k}。");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }

                    };
                    taskList.Add(taskFactory.StartNew(act, k));
                }
            }
            catch (AggregateException aex)
            {
                foreach (var item in aex.InnerExceptions)
                {
                    Console.WriteLine(item.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }

　　执行效果：

线程安全

        static void Main(string[] args)
        {
            TaskFactory taskFactory = new TaskFactory();
            List<Task> taskList = new List<Task>();
            List<int> intList = new List<int>();
            int count = 0;

            for (int i = 0; i < 10000; i++)
            {
                int k = i;
                taskList.Add(taskFactory.StartNew(() =>
                {
                    count += 1;
                    intList.Add(k);
                }));
            }
            Task.WaitAll(taskList.ToArray());
            Console.WriteLine($"count={count}");
            Console.WriteLine($"intList中元素的个数={intList.Count()}");

            Console.ReadKey();
        }

　执行效果：　 

从执行后的结果来看两个都不是10000，这是因为有的线程丢失了。
多个线程同时操作一个变量（包括：都能访问的局部变量、全局变量、数据库中的一个值），就会有某个操作会被覆盖的可能。

想要解决上面出现的问题，我们可以通过加lock 来实现。

        //private：防止外面使用；static：保障全局唯一；readonly：不能改动；object：引用类型
        private static readonly object threadLock = new object();
        static void Main(string[] args)
        {
            TaskFactory taskFactory = new TaskFactory();
            List<Task> taskList = new List<Task>();
            List<int> intList = new List<int>();
            int count = 0;

            for (int i = 0; i < 10000; i++)
            {
                int k = i;
                taskList.Add(taskFactory.StartNew(() =>
                {

                    lock (threadLock)
                    {
                        // 加lock 后就能保障任意时刻只有一个线程来执行该代码段
                        count += 1;
                        intList.Add(k);
                    }
                    //lock (this)
                    //{
                    //    // 使用this 要注意每次实例化是不同的锁，同一个实例是相同的锁。
                    //    // 但是这个实例别人也能访问到，别人也能锁定。 所以一般不要使用
                    //}

                }));
            }
            Task.WaitAll(taskList.ToArray());
            Console.WriteLine($"count={count}");
            Console.WriteLine($"intList中元素的个数={intList.Count()}");

            Console.ReadKey();
        }

　　执行效果：

使用lock 能解决线程线程安全，因为使用lock后只有一个线程可以进去，没有并发。虽然能解决问题，但是牺牲了性能。所以在使用lock来解决线程冲突的问题是要尽量缩小lock的范围。这种问题的最佳解决方案是，进行数据拆分，避免冲突。

await/async

在.NET Framework4.5框架、C#5.0语法中，新增加了async和await两个关键字。
async 用来标记一个方法为异步方法，方法体内需结合 await 关键字使用。异步方法命名规则通常以Async结尾。await 关键字只能在异步方法中使用。它出现在 Task 前面。
async和await 一般都是成对出现的，只有async 是没有意义的，只有await 就会报错。

static void Main(string[] args)
        {

            Console.WriteLine("执行前Main的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());
            TestAsync();
            Console.WriteLine("执行结束Main的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());

            Console.ReadKey();
        }

        private static async void TestAsync()
        {
            Console.WriteLine("执行前TestAsync的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());

            await Task.Run(()=> {
                Console.WriteLine("执行 Action 中Sleep之前 的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());
                Thread.Sleep(3000);
                Console.WriteLine("执行 Action 中Sleep之后 的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());
            });

            Console.WriteLine("执行结束TestAsync的线程ID:" + Thread.CurrentThread.ManagedThreadId.ToString());
        }

　　执行效果：