C# 多线程编程及其几种方式

引言：

进程（process）：应用程序的实例要使用的资源的集合。每个进程被赋予了一个虚拟地址空间，确保在一个进程中使用的代码和数据无法由另一个进程访问。

线程（thread）:程序中的一个执行流，每个线程都有自己的专有寄存器（栈指针、程序计数器等），但代码区是共享的，及不同的线程可以执行相同的函数。

多线程编程优缺点，

优点：可以提高CPU利用率。

缺点：

1、线程越多占用内存越多；

2、多线程需要协调和管理，需要CPU时间跟踪线程；

3、线程之间对共享资源会相互影响，必须解决竞用共享资源问题；

4、线程太多会导致控制太复杂，可能造成很多BUG

一、用Thread类开启线程

　　关键字：前台线程，后台线程，线程优先级，线程休眠，线程阻塞。

　　前台线程：主线程结束后，前台线程将继续执行才结束。

　　后台线程：主线程结束后，后台线程不管有没有完成也结束线程

class MultiThreadingApplication {
        static void Main(string[] args) {
            //Thread thread1 = new Thread(new ThreadStart(Test1));
            Thread thread1 = new Thread(Test1);//线程传入无参数委托实例
            //Thread thread2 = new Thread(new ParameterizedThreadStart(Test2));//正常传递
            Thread thread2 = new Thread(Test2);//简化传递
            thread1.Name = "线程1";
            thread1.IsBackground = true;//设为后台线程，主线成结束后台线程自动结束;前台线程在主线程结束后继续执行才结束
            thread2.Name = "线程2";
            thread1.Start();
            thread2.Start("HelloWorld");
            Thread thread3 = new Thread(() =>
            {
                Console.WriteLine("线程3开始");
                Console.WriteLine("线程3阻塞5秒钟");
                Thread.CurrentThread.Join(TimeSpan.FromSeconds(5));
                Console.WriteLine("{0}的执行方法",Thread.CurrentThread.Name);
                Console.WriteLine("线程3结束");
            });
            thread3.Name = "线程3";
            thread3.Priority = ThreadPriority.Highest;//线程优先级枚举设定，此时最高，在线程池中会优先开始
            thread3.Start();
            Console.WriteLine("Main()主函数线程结束");
        }

        static void Test1() {
            Console.WriteLine("线程1开始");
            Console.WriteLine("线程1休眠2秒钟");
            Thread.Sleep(2000);
            Console.WriteLine("{0}调用的无参数方法",Thread.CurrentThread.Name);
            Console.WriteLine(Thread.CurrentThread.Name+"结束");
        }

        static void Test2(object s) {
            Console.WriteLine("线程2开始");
            Console.WriteLine("{0}调用的有参数方法，方法的参数是：{1}", Thread.CurrentThread.Name, s);
            Console.WriteLine(Thread.CurrentThread.Name + "结束");
        }
    }  

 　　Thread Join()使用，在两个线程调用之间使用，阻塞当前线程，直到另一个线程结束。将两个交替的线程合并为顺序执行的线程。

比如在主线程中调用后台子线程的方法Join()，直到后台子线程执行完毕，主线程才继续执行。

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            var t = new Thread(() =>
            {
                Console.WriteLine("后台子线程开始");
                Thread.Sleep(3000);
                Console.WriteLine("后台子线程");
                Console.WriteLine("后台子线程结束");
            });
            t.IsBackground = true;
            t.Start();
            t.Join();//等待后台子线程执行完成，才继续执行主线程，主线程在这里被阻塞。
            //t.Join(TimeSpan.FromSeconds(5));
            //t.Join(5000);//主线程阻塞等待后台子线程执行5秒钟，然后继续执行主线程，5秒后不管后台子线程是否执行完成。
            //Thread.CurrentThread.Join();//死锁情况，A线程和B线程为同一个线程，将一直阻塞。
            Console.WriteLine("主线程结束");
        }

 二、通过线程池类ThreadPool开启线程

static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            ThreadPool.QueueUserWorkItem(DownLoadFile);
            //使用ThreadPool线程池开启一个线程
            ThreadPool.QueueUserWorkItem((p) =>
            {
                Console.WriteLine("是否线程池线程：{0}",Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("开启了一个线程，线程ID：{0}",Thread.CurrentThread.ManagedThreadId);
            });
            Thread.Sleep(5000);
            Console.WriteLine("主线程结束");
        }

        static void DownLoadFile(object state)
        {
            Console.WriteLine("开始下载...    线程ID：" + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(2000);
            Console.WriteLine("下载完成！");
        }

 三、Task或TaskFactory方式开启，叫法不同了，任务并行编程

Task需要启动任务执行，TaskFactory创建及开始执行

Task开启的是后台线程

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            //.net framework 4.0 TPL（Task Parallel Library, 简称TPL）任务并行库方式，类似于线程处理方式，抽象级别更高
            //任务并行，一个或多个任务同时运行
            //系统资源的使用效率更高，可伸缩性更好
            //TPL提供了一组简单丰富的 API，这些 API 支持等待、取消、继续、可靠的异常处理、详细状态、自定义计划等功能。
            //降低多线程编码和并行编程的复杂度，提升开发效率
            //使用Task开启一个任务(其实也是一个线程)
            Task task = new Task(new Action(() =>
            {
                Console.WriteLine("是否线程池线程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("开启了一个线程，线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            }));
            task.Start();

            Task.Factory.StartNew(() =>
            {
                Console.WriteLine("是否线程池线程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("开启了一个线程，线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            });

            TaskFactory tf = new TaskFactory();
            tf.StartNew(() =>
            {
                Console.WriteLine("是否线程池线程：{0}", Thread.CurrentThread.IsThreadPoolThread);
                Console.WriteLine("开启了一个线程，线程ID：{0}", Thread.CurrentThread.ManagedThreadId);
            });29 
            Thread.Sleep(2000);
            Console.WriteLine("主线程结束");
        }

 CancellationToken 传入取消令牌，外部控制任务内部结束

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            var cts = new CancellationTokenSource();
            var task = new Task<int>(()=> {
                return TaskAction("task", 10, cts.Token);
            });
            task.Start();
            Console.WriteLine(task.Status);
            cts.Cancel();
            Console.WriteLine(task.Status);
            task.Wait();
            Thread.Sleep(2000);
            Console.WriteLine(task.Status);
            Console.WriteLine("task结果：{0}",task.Result);
            Console.WriteLine("主线程结束");
        }

        static int TaskAction(string name, int seconds, CancellationToken token) {
            Console.WriteLine("Task:{0} is runing on Thread:{1}",name,Thread.CurrentThread.ManagedThreadId);
            for (int i = 0; i < seconds; i++)
            {
                Thread.Sleep(1000);
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("请求取消令牌产生作用");
                    return -1;
                }
            }
            return 42 * seconds;
        }

 创建任务集合及返回结果

static void Main(string[] args)
        {
            //Task<T>，Result等待任务调用完成得到结果，有Wait的作用
            var tasks = new List<Task<string>>() {
                Task.Factory.StartNew(()=> {
                    return "task1";
                }),
                Task.Factory.StartNew(()=> {
                    return "task2";
                }),
                Task.Factory.StartNew(()=> {
                    return "task3";
                }),
            };

            foreach (var task in tasks)
            {
                Console.WriteLine(task.Result);
            }
        }

异常捕获

通过Catch捕获Task的异常是AggregateException，一个被封装的异常，需要通过InnerException访问底层异常

推荐使用GetWaiter和GetResult方法访问Task的结果，可以获取到原始异常；

通过ContinueWith处理OnlyOnFaulted事件，捕获的异常也是一个被封装的异常，需要通过InnerException访问底层异常

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            Task<int> task = null;
            try
            {
                task = Task.Run(() => TaskExceptionAction("Task1", 2));
                var result = task.Result;
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine("Task 1 Exception,type:" + e.GetType() + ",Message:" + e.Message);
            }
            Console.WriteLine("==============================");
            try
            {
                task = Task.Run(() => TaskExceptionAction("Task2", 2));
                var result = task.GetAwaiter().GetResult();
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine("Task 2 Exception,type:" + e.GetType() + ",Message:" + e.Message);
            }

            var task3 = new Task<int>(() =>
            {
                return TaskExceptionAction("task3", 2);
            });
            var continueTask = Task.WhenAll(task3);
            continueTask.ContinueWith(t =>
            {
                Console.WriteLine("Task 3 Exception,type:" + t.Exception.GetType() + ",Message:" + t.Exception.Message);
            }, TaskContinuationOptions.OnlyOnFaulted);
            task3.Start();
            task3.Wait();
            Console.WriteLine("主线程结束");
        }

        static int TaskExceptionAction(string name, int seconds)
        {
            Console.WriteLine("任务：{0} 在线程：{1}上运行", name, Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(seconds * 1000);
            throw new Exception("Error");
        }

 多任务的串行化

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            var queryTask = new Task<string>(() =>
            {
                Console.WriteLine("Start queryTask!");
                return "QueryResult";
            });
            var analyzeTask = queryTask.ContinueWith((queryResult) =>
            {
                Console.WriteLine("Start AnalyzeTask!");
                return "Analyzed Data:" + queryResult.Result;
            });
            var reportTask = analyzeTask.ContinueWith((analyzeResult) =>
            {
                Console.WriteLine("Start ReportTask!");
                return "Reporting Data:" + analyzeResult.Result;
            });
            queryTask.Start();
            Console.WriteLine(reportTask.Result);
            Console.WriteLine("主线程结束");
        }

 除非所有子任务（子任务的子任务）结束运行，否则创建任务（父任务）不会认为已经结束

父任务异常不会影响子任务执行

子任务异常不会影响父任务执行

 static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");
            var parentTask = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("创建一个父任务");
                var subTask = Task.Factory.StartNew(() =>
                {
                    Console.WriteLine("创建一个子任务");
                    throw new Exception("subTask Error");
                }, TaskCreationOptions.AttachedToParent);
                Console.WriteLine("父任务结束");
            });
            Thread.Sleep(5000);
            Console.WriteLine("主线程结束");
        }

 四、异步委托开启多线程

//TODO

部分内容来自：https://www.cnblogs.com/tianqing/p/6970331.html