一文带你搞懂C#多线程的5种写法

最新推荐文章于 2024-07-29 13:46:39 发布

卖烤麸烤饼儿

最新推荐文章于 2024-07-29 13:46:39 发布

阅读量4w

点赞数 96

分类专栏： C# 文章标签：多线程 thread c# 线程池

本文链接：https://blog.csdn.net/qq_44705559/article/details/117382445

版权

C# 专栏收录该内容

3 篇文章 4 订阅

订阅专栏

一文带你搞懂C#多线程的5种写法

1.简介

超长警告！
在学习本篇文章前你需要学习的相关知识：
线程基本知识

此篇文章简单总结了C#中主要的多线程实现方法，包括：

Thread
线程
ThreadPool
线程池
Parallel
Task
任务
BackgroundWorker组件

2. Thread类

2.1 概述

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

2.1 属性表

属性	说明
Name	属性，获取或设置线程的名称
Priority	属性，获取或设置线程的优先级
ThreadState	属性，获取线程当前的状态
IsAlive	属性，获取当前线程是否处于启动状态
IsBackground	属性，获取或设置值，表示该线程是否为后台线程
CurrentThread	属性，获取当前正在运行的线程

2.2 方法表

方法	说明
Start()	方法，启动线程
Sleep(int millisecondsTimout)	方法，将当前线程暂停指定的毫秒数
Suspend()	方法，挂起当前线程（已经被弃用）
Join()	方法，阻塞调用线程，直到某个线程终止为止
Interrupt()	方法，中断当前线程
Resume()	方法，继续已经挂起的线程（已经被弃用）
Abort()	方法，终止线程（已经被弃用）

2.3 开启线程

首先用new申请Thread对象，然后对象调用Start()方法启用线程。

代码如下所示：

class Program
{
    static void DownLoad()
    {
        Console.WriteLine("DownLoad Begin " + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(1000);
        Console.WriteLine("DownLoad End");
    }
    static void Main(string[] args)
    {
        //创建Thread对象
        Thread thread = new Thread(DownLoad);
        //启动线程
        thread.Start();
        Console.WriteLine("Main");
        Console.ReadKey();
    }
}

Thread.CurrentThread.ManagedThreadId获取当前线程的ID，便于管理。

用Lambda表达式代替函数调用，也能达到相同的效果

class Program
{
    static void Main(string[] args)
    {
        Thread thread = new Thread(() =>
        {
            Console.WriteLine("DownLoad Begin " + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000);
            Console.WriteLine("DownLoad End");
        });
        thread.Start();
        Console.WriteLine("Main");
        Console.ReadKey();
    }
}

2.4 传递参数

有两种为线程传递参数的方法：

Start()函数传参法
对象成员方法传参法
匿名方法传参法

2.4.1 Start()函数传参

为某方法创建新线程后，在使用Start()方法启动线程时传递该方法需要的参数。

代码如下：

class Program
{
    static void DownLoad(object name)
    {
        Console.WriteLine("DownLoad Begin " + name);
        Thread.Sleep(1000);
        Console.WriteLine("DownLoad End");
    }
    static void Main(string[] args)
    {
        //创建Thread对象
        Thread thread = new Thread(DownLoad);
        //启动线程
        thread.Start("April");
        Console.WriteLine("Main");
        Console.ReadKey();
    }

2.4.1 对象传递

初始化一个对象，然后用对象的方法初始化Thread，这样该线程就可以使用这个对象的所有成员。

class Program
{
    public class Download
    {
        private int Id;
        private string Name;
        public Download(int id, string name)
        {
            Id = id;
            Name = name;
        }
        public void DownloadFile()
        {
            Console.WriteLine("DownLoad Begin " + "ID: " + Id + " Name: " + Name);
            Thread.Sleep(1000);
            Console.WriteLine("DownLoad End");              
        }
    }
    static void Main(string[] args)
    {
        Download download = new Download(1, "人民日报");
        Thread thread = new Thread(download.DownloadFile);
        thread.Start();
        Console.WriteLine("Main");
        Console.ReadKey();
    }
}

2.4.5 匿名方法

需要接收多个参数的解决方案是使用一个匿名方法调用，方法如下

static void Main() {
Thread t = new Thread(delegate() { WriteText ("Hello"); });

t.Start();

}

static void WriteText (stringtext) { Console.WriteLine (text); }

它的优点是目标方法（这里是WriteText），可以接收任意数量的参数，并且没有装箱操作。

不过这需要将一个外部变量放入到匿名方法中，如下示例：

static voidMain() {
stringtext = "Before";

Threadt = new Thread(delegate() { WriteText (text); });

text = "After";

t.Start();

}

static void WriteText (stringtext) { Console.WriteLine (text); }

需要注意的是:
当外部变量的值被修改，匿名方法可能进行无意的互动，导致一些古怪的现象。
一旦线程开始运行，外部变量最好被处理成只读的——除非有人愿意使用适当的锁。

2.5 线程命名

线程可以通过它的Name属性进行命名，这非常有利于调试：
可以用Console.WriteLine打印出线程的名字
Microsoft Visual Studio可以将线程的名字显示在调试工具栏的位置上。

线程的名字可以在被任何时间设置——但只能设置一次，重命名会引发异常。

程序的主线程也可以被命名，下面例子里主线程通过CurrentThread命名：

Class ThreadNaming {
static void Main() {
Thread.CurrentThread.Name= "main";

Thread worker = new Thread(Go);

worker.Name= "worker";

worker.Start();

Go();

}

static void Go() {
Console.WriteLine ("Hello from "+ Thread.CurrentThread.Name);

}

}

输出

Hellofrom main

Hellofrom worker

2.6 前台线程和后台线程

前台线程(用户界面线程)
只要存在有一个前台线程在运行，应用程序就在运行
通常用来处理用户的输入并响应各种事件和消息
后台线程(工作线程)
应用程序关闭时，如果后台线程没有执行完，会被强制性的关闭
用来执行程序的后台处理任务，比如计算、调度、对串口的读写操作等

例如：

class Program
{
    static void DownLoad()
    {
        Console.WriteLine("DownLoad Begin " + Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(1000);
        Console.WriteLine("DownLoad End");
    }
    static void Main(string[] args)
    {
        //创建Thread对象
        Thread thread = new Thread(DownLoad);
        //设为后台线程
        thread.IsBackground = true;
        //启动线程
        thread.Start();
        Console.WriteLine("Main");
    }
}

在上例中，thread被设置为后台线程。
Main执行完后，没有前台线程了，应用程序就结束，虽然后台线程thread此时尚未执行完，也被终止。

改变线程从前台到后台不会以任何方式改变它在CPU协调程序中的优先级和状态。

拥有一个后台工作线程是有益的，
最直接的理由是当提到结束程序它总是可能有最后的发言权。
交织以不会消亡的前台线程，保证程序的正常退出。

抛弃一个前台工作线程是尤为险恶的，尤其对Windows Forms程序，
因为程序直到主线程结束时才退出（至少对用户来说），但是它的进程仍然运行着。
在Windows任务管理器它将从应用程序栏消失不见，但却可以在进程栏找到它。
除非用户找到并结束它，它将继续消耗资源，并可能阻止一个新的实例的运行从开始或影响它的特性。

对于程序失败退出的普遍原因就是存在“被忘记”的前台线程。

线程类型	动作	结束	后续处理
前台线程	主程序关闭	否	显示关闭线程/杀掉当前进程
后台线程	主程序关闭	是	无

2.7 注意事项

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

用Thread类创建的线程是前台线程，线程池中的线程总是后台线程
可以通过Priority属性设置线程的优先级。
线程内部可以通过try catch捕获该异常，在catch模块中进行一些必要的处理
如释放持有的锁和文件资源等
慎重使用Abort()方法
如果在当前线程中抛出该异常，其结果是可预测的
但是对于其他线程，它会中断任何正在执行的代码，有可能中断静态对象的生成，造成不可预测的结果。

3. 线程池

3.1 概述

ThreadPool类维护一个线程的列表，提供给用户以执行不同的小任务，减少频繁创建线程的开销。
该线程池可用于执行任务、发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。

线程池其实就是一个存放线程对象的“池子(pool)”，他提供了一些基本方法，如：设置pool中最小/最大线程数量、把要执行的方法排入队列等等。ThreadPool是一个静态类，因此可以直接使用，不用创建对象。

3.2 线程池的优点

每新建一个线程都需要占用内存空间和其他资源
而新建了那么多线程，有很多在休眠，或者在等待资源释放；
又有许多线程只是周期性的做一些小工作，如刷新数据等等，太浪费了，划不来。
实际编程中大量线程突发，然后在短时间内结束的情况很少见。

于是，就提出了线程池的概念。

线程池中的线程执行完指定的方法后并不会自动消除，而是以挂起状态返回线程池，如果应用程序再次向线程池发出请求，那么处以挂起状态的线程就会被激活并执行任务，而不会创建新线程，这就节约了很多开销。
只有当线程数达到最大线程数量，系统才会自动销毁线程。

因此，使用线程池可以避免大量的创建和销毁的开支，具有更好的性能和稳定性，其次，开发人员把线程交给系统管理，可以集中精力处理其他任务。

3.3 线程池的使用

设置线程池最大最小：
ThreadPool.SetMaxThreads (int workerThreads,int completionPortThreads)
设置可以同时处于活动状态的线程池的请求数目。
所有大于此数目的请求将保持排队状态，直到线程池线程变为可用。
还可以设置最小线程数。
将任务添加进线程池:
**ThreadPool.QueueUserWorkItem(new WaitCallback(方法名));**或
ThreadPool.QueueUserWorkItem(new WaitCallback(方法名), 参数);

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

线程池中的线程均为后台线程，并且不能修改为前台线程
不能给入池的线程设置优先级或名称
对于COM对象，入池的所有线程都是多线程单元（MTA）线程，许多COM对象都需要单线程单元（STA）线程
入池的线程只适合时间较短的任务，如果线程需要长时间运行，应使用Thread类创建线程或使用Task的LongRunning选项
.Net下线程池最小默认允许4个工作线程，最大允许2048个工作线程。
并发线程启动后，瞬间会启动4个线程。
而剩下的会依据环境每0.5秒或者1秒启动一个。
如果同时运行的线程达到Max工作线程，那么剩下的就会挂起
直到线程池中的线程有空闲得了，才会去执行。

4. Parallel类

4.1 概述

整理自https://blog.csdn.net/honantic/article/details/46876871

Parallel和Task类都位于System.Threading.Task命名空间中，是对Thread和ThreadPool类更高级的抽象。

Parrallel类有For()、ForEach()、Invoke()三个方法

Invoke()
实现任务并行性
允许同时调用不同的方法，
Parallel.For()和 Parallel.ForEach()
实现数据并行性
在每次迭代中调用相同的代码

4.2 常用方法

4.2.1 Parallel.For()

Parallel.For()方法类似于 C#的 for循环语旬,也是多次执行一个任务。
使用Parallel.For()方法,可以并行运行迭代。

迭代的顺序没有定义，不能保证。

在For()方法中：

前两个参数定义了循环的开头和结束。示例从0迭代到 9。
第 3个参数是一个Action委托
是要并行运行迭代的方法
整数参数是循环的迭代次数,该参数被传递给Action委托引用的方法。
Parallel.For()方法的返回类型是ParalleLoopResult结构,它提供了循环是否结束的信息。

案例如下：

        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();
        }

同For()循环类似，Parallel.For()方法也可以中断循环的执行。

Parallel.For()方法的一个重载版本接受第3个Action<int, ParallelLoopState>类型的参数。
使用这些参数定义一个方法,就可以调用ParalleLoopState的Break()或Stop()方法,以影响循环的结果。

注意,迭代的顺序没有定义

案例如下：

        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();
        }

4.2.2 Parallel.For < TLocal >

Parallel.For()方法可能使用几个线程来执行循环。

如果需要对每个线程进行初始化,就可以使用Parallel.For方法。
除了from和to对应的值之外,For()方法的泛型版本还接受3个委托参数:

第一个参数的类型是Func< TLocal >
因为这里的例子对于TLocal使用字符串,所以该方法需要定义为Func< string >,即返回string的方法。
这个方法仅对于用于执行迭代的每个线程调用一次
第二个委托参数为循环体定义了委托
在示例中,该参数的类型是Func<int, ParallelLoopState, string, string>。
其中第一个参数是循环迭代,第二个参数 ParallelLoopstate允许停止循环,如前所述。
循环体方法通过第3个参数接收从init方法返回的值,循环体方法还需要返回一个值,其类型是用泛型for参数定义的。
For()方法的最后一个参数指定一个委托Action< TLocal >;在该示例中,接收一个字符串。
这个方法仅对于每个线程调用一次,这是一个线程退出方法。

案例如下：

Parallel.For<string>(0, 20,() =>
                {
                    Console.WriteLine("init thread {0},\t task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
                    return string.Format("t{0}", Thread.CurrentThread.ManagedThreadId);
                },
            (i, pls, str) =>
            {
                Console.WriteLine("body i {0} \t str {1} \t thread {2} \t task {3}", i, str, Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
                Thread.Sleep(10);
                return string.Format("i \t{0}", i);
            },
            (str) =>
            {
                Console.WriteLine("finally\t {0}", str);
            });
            Console.ReadKey();

Parallel.For 方法 (Int32, Int32, Func, Func<Int32, ParallelLoopState, TLocal, TLocal>, Action)

参数表：

参数名	数据类型	作用
	TLoca	线程本地数据的类型
fromInclusive	System.Int32	开始索引（含）
toExclusive	System.Int32	结束索引（不含）
localInit	System.Func	用于返回每个任务的本地数据的初始状态的函数委托
body	System.Func<Int32, ParallelLoopState, TLocal, TLocal>	将为每个迭代调用一次的委托
localFinally	System.Action	用于对每个任务的本地状态执行一个最终操作的委托
返回值	System.Threading.Tasks.ParallelLoopResult

在迭代范围 (fromInclusive，toExclusive) ，为每个值调用一次body 委托。
为它提供以下参数：

迭代次数 (Int32)
可用来提前退出循环的ParallelLoopState实例
可以在同一线程上执行的迭代之间共享的某些本地状态。

对于参与循环执行的每个任务调用 localInit 委托一次，并返回每个任务的初始本地状态。
这些初始状态传递给第一个在该任务上调用的 body。
然后，每个后续正文调用返回可能修改过的状态值，传递到下一个正文调用。
最后，每个任务上的最后正文调用返回传递给 localFinally 委托的状态值。
每个任务调用 localFinally 委托一次，以对每个任务的本地状态执行最终操作。
此委托可以被多个任务同步调用；
因此您必须同步对任何共享变量的访问。

Parallel.For方法比在它执行生存期的线程可能使用更多任务，作为现有的任务完成并被新任务替换。
这使基础 TaskScheduler 对象有机会添加、更改或移除服务循环的线程。

如果 fromInclusive 大于或等于 toExclusive，则该方法立即返回，而无需执行任何迭代。

4.2.3 Parallel.ForEach()

Parallel.ForEach()方法遍历实现了IEnumerable的集合,其方式类似于foreach语句,但以异步方式遍历。
这里也没有确定遍历顺序。

string[] data = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve" };
            ParallelLoopResult result = Parallel.ForEach<string>(data, (s) =>
            {
                Console.WriteLine(s);
            });
            Console.ReadKey();

中断循环
如果需要中断循环,就可以使用ForEach()方法的重载版本和ParallelLoopState参数。其方式与前面的For()方法相同。
ForEach()方法的一个重载版本也可以用于访问索引器,从而获得迭代次数
如下所示:

string[] data = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve" };
            ParallelLoopResult result = Parallel.ForEach<string>(data, (s, pls, l) =>
             {
                 Console.WriteLine("{0}\t{1}", s, l);
                 if (l > 10)
                 {
                     pls.Break();
                 }
             });
            Console.WriteLine("Lowest break iteration: {0}", result.LowestBreakIteration);
            Console.ReadKey();

4.2.4 Parallel.Invoke()

如果多个任务应并行运行,就可以使用Parallel.Invoke()方法。
Parallel.Invoke()方法允许传递一个Action委托数组,在其中可以指定应运行的方法。
示例代码传递了要并行调用的Foo()和Bar()方法:

    static void Main(string[] args)
    {
        Parallel.Invoke(Foo, Bar);
        Console.ReadKey();
    }
    static void Foo()
    {
        Console.WriteLine("Foo");
    }

    static void Bar()
    {
        Console.WriteLine("Bar");
    }

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

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

5. Task类

5.1 概述

相比于Thread类，Task类为控制线程提供了更大的灵活性。

Task类可以获取线程的返回值
可以定义连续的任务：在一个任务结束结束后开启下一个任务
可以在层次结构中安排任务，在父任务中可以创建子任务
这样就创建了一种依赖关系，如果父任务被取消，子任务也随之取消

注意：
Task类默认使用线程池中的线程，如果该任务需长期运行，应使用TaskCreationOptions.LongRunning属性告诉任务管理器创建一个新的线程，而不是使用线程池中的线程。

5.2 任务Task和线程Thread的区别：

任务是架构在线程之上的
也就是说任务最终还是要抛给线程去执行。
任务跟线程不是一对一的关系
比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制。
Task和Thread一样，位于System.Threading命名空间下!

5.3 Task的生存周期与状态

状态	说明
Created	表示默认初始化任务，但是“工厂创建的”实例直接跳过。
WaitingToRun	这种状态表示等待任务调度器分配线程给任务执行。
RanToCompletion	任务执行完毕。

//查看Task中的状态
   var task1 = new Task(() =>
         {
            Console.WriteLine("Begin");
            System.Threading.Thread.Sleep(2000);
            Console.WriteLine("Finish");
         });
         Console.WriteLine("Before start:" + task1.Status);
         task1.Start();
         Console.WriteLine("After start:" + task1.Status);
         task1.Wait();
         Console.WriteLine("After Finish:" + task1.Status);

5.4 Task的使用方法

5.4.1 启动任务

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

实例化后手动start()

var task1 = new Task(() =>
    {
       //TODO you code
    });
   task1.Start();

使用Task工厂对象创建新任务并执行

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");

案例如下：

    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);
            }
        }
    }

5.4.2 任务控制

5.4.2.1 Task.Wait()

就是等待任务执行（task1）完成，task1的状态变为Completed。

5.4.2.2 Task.WaitAll()

等待所有的任务都执行完成：
例如：

Task.WaitAll(task,task2,task3...N)
Console.WriteLine("All task finished!");

即当task,task2,task3…N全部任务都执行完成之后才会往下执行代码（打印出：“All task finished!”）

5.4.2.3 Task.WaitAny()

同Task.WaitAll，等待任何一个任务完成就继续向下执行，将上面的代码WaitAll替换为WaitAny

Task.WaitAny(task,task2,task3...N)
Console.WriteLine("Any task finished!");

即当task,task2,task3…N任意一个任务都执行完成之后就会往下执行代码（打印出：” Any task finished!”）

5.4.2.4 Task.ContinueWith()

在第一个Task完成后自动启动下一个Task，实现Task的延续，编写如下代码：

        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);  
}

5.4.2.5 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
        }

5.4.3 任务取消

当我们启动了一个task,出现异常或者用户点击取消等等，我们可以取消这个任务。

我们通过cancellation的tokens来取消一个Task。
在很多Task的Body里面包含循环，我们可以在轮询的时候判断IsCancellationRequested属性是否为True
如果是True的话就return或者抛出异常，抛出异常后面再说，因为还没有说异常处理的东西。

下面在代码中看下如何实现任务的取消，代码如下：

　　　　var tokenSource = new CancellationTokenSource();
            var token = tokenSource.Token;
            var task = Task.Factory.StartNew(() =>
            {
                for (var i = 0; i < 1000; i++)
                {
                    System.Threading.Thread.Sleep(1000);
                    if (token.IsCancellationRequested)
                    {
                        Console.WriteLine("Abort mission success!");
                        return;
                    }
                }
            }, token);
            token.Register(() =>
            {
                Console.WriteLine("Canceled");
            });
            Console.WriteLine("Press enter to cancel task...");
            Console.ReadKey();
            tokenSource.Cancel();123456789101112131415161718192021

这里开启了一个Task,并给token注册了一个方法，输出一条信息，然后执行ReadKey开始等待用户输入，用户点击回车后，执行tokenSource.Cancel方法，取消任务。

注意：
因为任务通常运行以异步方式在线程池线程上，创建并启动任务的线程将继续执行，一旦该任务已实例化。
在某些情况下，当调用线程的主应用程序线程，该应用程序可能会终止之前任何任务实际开始执行。
其他情况下，应用程序的逻辑可能需要调用线程继续执行，仅当一个或多个任务执行完毕。
您可以同步调用线程的执行，以及异步任务它启动通过调用 Wait 方法来等待要完成的一个或多个任务。
若要等待完成一项任务，可以调用其 Task.Wait 方法。
调用 Wait 方法将一直阻塞调用线程直到单一类实例都已完成执行。

5.4.4 接收任务的返回值

对于任务有返回值的情况，可使用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;
        }

5.5 任务的层次结构

如果在一个Task内部创建了另一个任务，这两者间就存在父/子的层次结构，当父任务被取消时，子任务也会被取消。

如果不希望使用该层次结构，可在创建子任务时选择TaskCreationOptions.DetachedFromParent。

6. BackgroundWorker控件

6.1 概述

C#提供了BackgroundWorker控件帮助用户更简单、安全地实现多线程运算。

该控件提供了DoWork, ProgressChanged 和 RunWorkerCompleted事件
为DoWork添加事件处理函数，再调用RunWorkerAsync()方法，即可创建一个新的线程执行DoWork任务

ProgressChanged和RunWorkerCompleted事件均在UI线程中执行，添加相应的处理函数，即可完成任务线程与UI线程间的交互，可用于显示任务的执行状态（完成百分比）、执行结果等。

同时，该控件还提供了CancleAsync()方法，以中断线程的执行
需注意的是，调用该方法后，只是将控件的CancellationPending属性置True，用户需在程序执行过程中查询该属性以判定是否应中断线程。

具体用法可参考MSDN：BackgroundWorker用法范例
可以看的出来，BackgroundWorker组件提供了一种执行异步操作（后台线程）的同时，并且还能妥妥的显示操作进度的解决方案。

6.2 属性表

6.2.1 WorkerReportsProgress

bool类型，指示BackgroundWorker是否可以报告进度更新。

True时，可以成功调用ReportProgress方法
否则将引发InvalidOperationException异常

用法：

private BackgroundWorker bgWorker = new BackgroundWorker();
bgWorker.WorkerReportsProgress = true;

6.2.2 WorkerSupportsCancellation

bool类型，指示BackgroundWorker是否支持异步取消操作

True时，将可以成功调用CancelAsync方法
否则将引发InvalidOperationException异
用法：

  bgWorker.WorkerSupportsCancellation = true;

6.2.3 CancellationPending

bool类型，指示应用程序是否已请求取消后台操作。
此属性通常放在用户执行的异步操作内部，用来判断用户是否取消执行异步操作。
当执行BackgroundWorker.CancelAsync()方法时，该属性值将变为True。
用法：

//在DoWork中键入如下代码
  for (int i = 0; i <= 100; i++)
  {
      if (bgWorker.CancellationPending)
      {
          e.Cancel = true;
          return;
      }
      else
      {
          bgWorker.ReportProgress(i,"Working");
          System.Threading.Thread.Sleep(10);
      }
  }

6.2.4 IsBusy

bool类型，指示BackgroundWorker是否正在执行一个异步操作。
此属性通常放在BackgroundWorker.RunWorkerAsync()方法之前，避免多次调用RunWorkerAsync()方法引发异常。
当执行BackgroundWorker.RunWorkerAsync()方法是，该属性值将变为True。

 //防止重复执行异步操作引发错误
  if (bgWorker.IsBusy)
      return;
  bgWorker.RunWorkerAsync();

6.3 方法表

6.3.1 RunWorkerAsync()

开始执行一个后台操作。

调用该方法后，将触发BackgroundWorker.DoWork事件，并以异步的方式执行DoWork事件中的代码。
该方法还有一个带参数的重载方法：RunWorkerAsync(Object)。
该方法允许传递一个Object类型的参数到后台操作中，并且可以通过DoWork事件的DoWorkEventArgs.Argument属性将该参数提取出来。

注：当BackgroundWorker的IsBusy属性为True时，调用该方法将引发InvalidOperationException异常。

//在启动异步操作的地方键入代码
bgWorker.RunWorkerAsync("hello");

6.3.2 ReportProgress(Int percentProgress)

报告操作进度。

调用该方法后，将触发BackgroundWorker. ProgressChanged事件。
另外，该方法包含了一个int类型的参数percentProgress，用来表示当前异步操作所执行的进度百分比。

该方法还有一个重载方法：ReportProgress(Int percentProgress, Object userState)。
允许传递一个Object类型的状态对象到 ProgressChanged事件中
并且可以通过ProgressChanged事件的ProgressChangedEventArgs.UserState属性取得参数值。

注：调用该方法之前需确保WorkerReportsProgress属性值为True，否则将引发InvalidOperationException异常。

用法：

for (int i = 0; i <= 100; i++)
{c
    //向ProgressChanged报告进度
    bgWorker.ReportProgress(i,"Working");
    System.Threading.Thread.Sleep(10);
}

6.3.3 CancelAsync()

请求取消当前正在执行的异步操作。

调用该方法将使BackgroundWorker.CancellationPending属性设置为True。
但需要注意的是，并非每次调用CancelAsync()都能确保异步操作，CancelAsync()通常不适用于取消一个紧密执行的操作，更适用于在循环体中执行。
用法：

//在需要执行取消操作的地方键入以下代码
bgWorker.CancelAsync();

6.4 事件表

6.4.1 DoWork

用于承载异步操作。当调用BackgroundWorker.RunWorkerAsync()时触发。

需要注意的是：
由于DoWork事件内部的代码运行在非UI线程之上，所以在DoWork事件内部应避免于用户界面交互，
而于用户界面交互的操作应放置在ProgressChanged和RunWorkerCompleted事件中。

6.4.2 ProgressChanged

当调用BackgroundWorker.ReportProgress(int percentProgress)方式时触发该事件。
该事件的ProgressChangedEventArgs.ProgressPercentage属性可以接收来自ReportProgress方法传递的percentProgress参数值,ProgressChangedEventArgs.UserState属性可以接收来自ReportProgress方法传递的userState参数。

6.4.3 RunWorkerCompleted

异步操作完成或取消时执行的操作，当调用DoWork事件执行完成时触发。

该事件的RunWorkerCompletedEventArgs参数包含三个常用的属性Error,Cancelled,Result。其中，Error表示在执行异步操作期间发生的错误；Cancelled用于判断用户是否取消了异步操作；Result属性接收来自DoWork事件的DoWorkEventArgs参数的Result属性值，可用于传递异步操作的执行结果。

6.3 案例

using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;
 
namespace bcworker
{
    public partial class Form1 : Form
    {
        //后台工作
        private BackgroundWorker bw = new BackgroundWorker();
 
        public Form1()
        {
            InitializeComponent();
            //后台工作初始化
            bw.WorkerReportsProgress = true;//报告进度
            bw.WorkerSupportsCancellation = true;//支持取消
            bw.DoWork += new DoWorkEventHandler(bgWorker_DoWork);//开始工作
            bw.ProgressChanged += new ProgressChangedEventHandler(bgWorker_ProgessChanged);//进度改变事件
            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgWorker_WorkerCompleted);//进度完成事件
        }
 
        private void btnStart_Click(object sender, EventArgs e)
        {
            //后台工作运行中，避免重入
            if (bw.IsBusy) return;
            bw.RunWorkerAsync("参数");//触发DoWork事件并异步执行，IsBusy置为True
        }
        //后台工作将异步执行
        public void bgWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            //(string)e.Argument == "参数";
            for (int i = 0; i <= 100; i++)
            {
 
                if (bw.CancellationPending)
                {//用户取消了工作
                    e.Cancel = true;
                    return;
                }
                else
                {
                    bw.ReportProgress(i, "Working");//报告进度，触发ProgressChanged事件
                    Thread.Sleep(10);//模拟工作
                }
            }
        }
        //进度改变事件
        public void bgWorker_ProgessChanged(object sender, ProgressChangedEventArgs e)
        {
            //(string)e.UserState=="Working"
            progressBar1.Value = e.ProgressPercentage;//取得进度更新控件，不用Invoke了
        }
        //后台工作执行完毕,IsBusy置为False
        public void bgWorker_WorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //e.Error == null 是否发生错误
            //e.Cancelled 完成是由于取消还是正常完成
        }
 
        private void btnCancel_Click(object sender, EventArgs e)
        {
            if (bw.IsBusy) bw.CancelAsync();//设置CancellationPending属性为True
        }
 
    }
}

卖烤麸烤饼儿

关注

96
点赞
踩
452

收藏

觉得还不错? 一键收藏
4
评论
一文带你搞懂C#多线程的5种写法

一文带你搞懂C#多线程的5种写法1.简介超长警告！在学习本篇文章前你需要学习的相关知识：线程基本知识此篇文章简单总结了C#中主要的多线程实现方法，包括：Thread线程ThreadPool线程池ParallelTask任务BackgroundWorker组件2. Thread类2.1 概述使用Thread类通过ThreadStart（无参数）或ParameterizedThreadStart（一个输入参数）类型的委托创建一个Thread对象，开启一个新线程，执行该委托
复制链接

扫一扫

专栏目录