C#多线程（补充）

C# 多线程的补充

在C#中使用多线程

1. Thread类

使用Thread类通过ThreadStart（无参数）或ParameterizedThreadStart（一个输入参数）类型的委托创建一个Thread对象，开启一个新线程，执行该委托传递的任务，此时线程尚未处于运行状态。调用Start()函数启动线程，当前线程继续执行。调用Join()函数可以阻塞当前线程，直到调用Join()的线程终止。

Thread类创建的线程默认为前台线程，可以通过IsBackground属性设置其为前台或后台线程。还可以通过Priority属性设置线程的优先级。

如需中止线程，调用Abort()方法，在调用该方法的线程上抛出ThreadAbortException异常，以结束该线程。线程内部可以通过try catch捕获该异常，在catch模块中进行一些必要的处理，如释放持有的锁和文件资源等，还可以通过Thread.ResetAbort()方法阻止线程的中止。但是通常来说，应当慎重使用Abort()方法，如果在当前线程中抛出该异常，其结果是可预测的，但是对于其他线程，它会中断任何正在执行的代码，有可能中断静态对象的生成，造成不可预测的结果。

using System;
using System.Threading;

namespace ConsoleApplication1
{
    public class ThreadExample
    {
        public static void Main()
        {
            Thread thread = new Thread(new ThreadStart(DoWork));
            thread.Start();
            //thread.Join();

            Thread.Sleep(10);
            thread.Abort();

            Thread parameterizedThread = new Thread(new ParameterizedThreadStart(DoWorkWithParam));
            parameterizedThread.Start("test");

            Console.ReadKey();
        }

        public static void DoWork()
        {
            try
            {
                for (int i = 0; i < 10000; i++)
                    Console.WriteLine("Work thread:" + i.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Thread.ResetAbort();
            }

            Console.WriteLine("Work thread: still alive and working.");
            Thread.Sleep(1000);
            Console.WriteLine("Work thread: finished working.");
        }

        public static void DoWorkWithParam(object obj)
        {
            string msg = (string)obj;
            Console.WriteLine("Parameterized Work thread:" + msg);
        }
    }
}

2. 线程池

ThreadPool类维护一个线程的列表，提供给用户以执行不同的小任务，减少频繁创建线程的开销。ThreadPool的使用比较简单，只需调用ThreadPool.QueueUserWorkItem()方法，传递一个WaitCallback类型的委托，线程池即从池中选择一个线程执行该任务。

public static void Main()
        {
            for (int i = 0; i < 5; ++i)
                ThreadPool.QueueUserWorkItem(DoWork);

            Console.ReadKey();
        }

        public static void DoWork(Object o)
        { 
                for (int i = 0; i < 3; i++)
                    Console.WriteLine("loop:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);
        }

但是线程池的使用也有一些限制：

线程池中的线程均为后台线程，并且不能修改为前台线程
不能给入池的线程设置优先级或名称
对于COM对象，入池的所有线程都是多线程单元（MTA）线程，许多COM对象都需要单线程单元（STA）线程
入池的线程只适合时间较短的任务，如果线程需要长时间运行，应使用Thread类创建线程或使用Task的LongRunning选项

3. Parallel类

Parallel和Task类都位于System.Threading.Task命名空间中，是对Thread和ThreadPool类更高级的抽象。Parrallel类有For()、ForEach()、Invoke()三个方法，前两者在每次迭代中调用相同的代码，实现了数据并行性，Invoke()允许同时调用不同的方法，实现任务并行性。

For()和ForEach()两者的用法类似。如下例，调用Parallel.For()方法，实现从0到10的迭代，每次迭代是并行执行的，并且从输出结果可以看出，执行顺序是不能保证的。

public static void Main()
        {
            ParallelLoopResult result = Parallel.For(0, 10, i =>
            {
                Console.WriteLine("i:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10);
            });

            Console.WriteLine("Is completed: {0}", result.IsCompleted);

            //i: 0, thread id: 9
            //i: 2, thread id: 10
            //i: 1, thread id: 9
            //i: 3, thread id: 10
            //i: 4, thread id: 9
            //i: 6, thread id: 11
            //i: 7, thread id: 10
            //i: 5, thread id: 9
            //i: 8, thread id: 12
            //i: 9, thread id: 11
            //Is completed: True

            Console.ReadKey();
        }

通过ParallelLoopState的Break()或Stop()方法，可以提前中断Parallel.For()的迭代。

public static void Main()
        {
            ParallelLoopResult result = Parallel.For(0, 100, (i, state) =>
            {
                Console.WriteLine("i:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);

                if (i > 10)
                    state.Break();

                Thread.Sleep(10);
            });

            Console.WriteLine("Is completed: {0}", result.IsCompleted);
            Console.WriteLine("Lowest break iteration: {0}", result.LowestBreakIteration);

            //i: 0, thread id: 10
            //i: 25, thread id: 6
            //i: 1, thread id: 10
            //i: 2, thread id: 10
            //i: 3, thread id: 10
            //i: 4, thread id: 10
            //i: 5, thread id: 10
            //i: 6, thread id: 10
            //i: 7, thread id: 10
            //i: 8, thread id: 10
            //i: 9, thread id: 10
            //i: 10, thread id: 10
            //i: 11, thread id: 10
            //Is completed: False
            //Lowest break iteration: 11

            Console.ReadKey();
        }

如需同时执行多个不同的任务，可以使用Parallel.Invoke()方法，它允许传递一个Action委托数组。

public static void Main()
        {
            Parallel.Invoke(Func1, Func2, Func3);
            Console.ReadKey();
        }

4. Task类

相比于Thread类，Task类为控制线程提供了更大的灵活性。Task类可以获取线程的返回值，也可以定义连续的任务——在一个任务结束结束后开启下一个任务，还可以在层次结构中安排任务，在父任务中可以创建子任务，这样就创建了一种依赖关系，如果父任务被取消，子任务也随之取消。Task类默认使用线程池中的线程，如果该任务需长期运行，应使用TaskCreationOptions.LongRunning属性告诉任务管理器创建一个新的线程，而不是使用线程池中的线程。

启动任务

以下程序演示了几种通过Task类启动任务的方式：

public class ThreadExample
    {
        public static void Main()
        {
            TaskFactory tf = new TaskFactory();
            Task t1 = tf.StartNew(TaskMethod.DoTask, "using a task factory");

            Task t2 = Task.Factory.StartNew(TaskMethod.DoTask, "factory via a task");

            Task t3 = new Task(TaskMethod.DoTask, "using a task constructor and start");
            t3.Start();

            //需要.NetFramework 4.5以上
            var t4 = Task.Run(() => TaskMethod.DoTask("using Run method"));

            Console.ReadKey();
        }

   class TaskMethod
    {
        static object taskLock = new object();
        public static void DoTask(object msg)
        {
            lock (taskLock)
            {
                Console.WriteLine(msg);
                Console.WriteLine("Task id:{0}, Thread id :{1}",
                               Task.CurrentId == null ? "no task" : Task.CurrentId.ToString(),
                               Thread.CurrentThread.ManagedThreadId);
            }
        }
    }

接收任务的返回值

对于任务有返回值的情况，可使用Task泛型类，TResult定义了返回值的类型，以下代码演示了调用返回int值的任务的方法。

public static void Main()
        {
            var t5 = new Task<int>(TaskWithResult, Tuple.Create<int, int>(1, 2));
            t5.Start();
            t5.Wait();
            Console.WriteLine("adder results: {0}", t5.Result);

            Console.ReadKey(); 
        }

        public static int TaskWithResult(object o)
        {
            Tuple<int, int> adder = (Tuple<int, int>)o;
            return adder.Item1 + adder.Item2;
        }

同步调用

调用Task类的RunSynchronously()方法，可以实现同步调用，直接在当前线程上调用该任务。

public static void Main()
        {
            TaskMethod.DoTask("Just Main thread");
            Task t1 = new Task(TaskMethod.DoTask, "using Run Sync");
            t1.RunSynchronously();
            //输出结果
            //Just Main thread
            //Task id: no task, Thread id: 9
            //
            //using Run Sync
            //Task id:1, Thread id :9
        }

指定连续任务

调用Task类的ContinueWith()方法，可以指定连续的任务。

public static void Main()
        {
            TaskFactory tf = new TaskFactory();
            Task t1 = tf.StartNew(()=>
            {
                Console.WriteLine("Current Task id = {0}", Task.CurrentId);
                Console.WriteLine("执行任务1\r\n");
                Thread.Sleep(10);
            });

            Task t2 = t1.ContinueWith((t) =>
            {
                Console.WriteLine("Last Task id = {0}", t.Id);
                Console.WriteLine("Current Task id = {0}", Task.CurrentId);
                Console.WriteLine("执行任务2\r\n");
                Thread.Sleep(10);
            });

            Task t3 = t2.ContinueWith(delegate(Task t) 
            {
                Console.WriteLine("Last Task id = {0}", t.Id);
                Console.WriteLine("Current Task id = {0}", Task.CurrentId);
                Console.WriteLine("执行任务3\r\n");
            }, TaskContinuationOptions.OnlyOnRanToCompletion);

            Console.ReadKey(); 
        }
            //执行结果
            //
            //Current Task id = 1
            //执行任务1

            //Last Task id = 1
            //Current Task id = 2
            //执行任务2

            //Last Task id = 2
            //Current Task id = 3
            //执行任务3

从执行结果可以看出，任务1，2，3被顺序执行，同时通过 TaskContinuationOptions 还可以指定何种情况下继续执行该任务，常用的值包括OnlyOnFaulted, OnlyOnCanceled, NotOnFaulted, NotOnCanceled等。如将上例中的OnlyOnRanToCompletion改为OnlyOnFaulted，任务2结束之后，任务3将不被执行。

对于ContinueWith()的使用，MSDN演示了更加优雅的“流式”调用方法：

private void Button1_Click(object sender, EventArgs e)  
{  
   var backgroundScheduler = TaskScheduler.Default;  
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();  
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },  
                         backgroundScheduler).  
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).  
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },  
                             backgroundScheduler).  
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);  
}

任务的层次结构

如果在一个Task内部创建了另一个任务，这两者间就存在父/子的层次结构，当父任务被取消时，子任务也会被取消。如果不希望使用该层次结构，可在创建子任务时选择TaskCreationOptions.DetachedFromParent。

5. BackgroundWorker控件

除了上述四类直接操作多线程的方法，C#还提供了BackgroundWorker控件帮助用户更简单、安全地实现多线程运算。该控件提供了DoWork, ProgressChanged 和 RunWorkerCompleted事件，为DoWork添加事件处理函数，再调用RunWorkerAsync()方法，即可创建一个新的线程执行DoWork任务。ProgressChanged和RunWorkerCompleted事件均在UI线程中执行，添加相应的处理函数，即可完成任务线程与UI线程间的交互，可用于显示任务的执行状态（完成百分比）、执行结果等。同时，该控件还提供了CancleAsync()方法，以中断线程的执行，需注意的是，调用该方法后，只是将控件的CancellationPending属性置True，用户需在程序执行过程中查询该属性以判定是否应中断线程。

C#多线程（补充）

C# 多线程的补充

在C#中使用多线程

1. Thread类

2. 线程池

3. Parallel类

4. Task类

任务的层次结构

5. BackgroundWorker控件

继续阅读

程序线程数合理配置

项目中如何合理的使用线程池～

线程池创建多少线程比较合理？线程池创建多少线程比较合理？

ExecutorService基本知识点学习，不同的线程池使用场景区分

Java并发编程之线程池的关闭

Java.util.concurrent之 Executor框架与线程池

线程池常用的阻塞队列有哪些？线程池常用的阻塞队列有哪些？

Springboot中异步操作的最佳实现方式

python爬取使用线程池出现报错：exception calling callback for <；Future at 0x1e8e963ef70 state=finished raised

游戏服务器架构基本模块及其作用

CLR线程池的工作者线程

Java并发编程一四种常用线程池简述

Java并发编程一线程池简介

Java并发编程一如何关闭线程池

python3源码剖析之concurrent.futures.ThreadPoolExecutor

Java并发编程一线程池的五种状态