多线程之任务: Task 基础, 多任务并行执行, 并行运算（Parallel）

Task - 基于线程池的任务（在 System.Threading.Tasks 命名空间下）

• 多 Task 的并行执行
• Parallel - 并行计算（在 System.Threading.Tasks 命名空间下）

示例
1、演示 Task（基于线程池的任务）的基本应用
Thread/Tasks/TaskDemo.xaml

<Page
    x:Class="XamlDemo.Thread.Tasks.TaskDemo"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:XamlDemo.Thread.Tasks"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
 
    <Grid Background="Transparent">
        <StackPanel Margin="120 0 0 0">
 
            <TextBlock Name="lblMsg" FontSize="14.667" />
 
            <Button Name="btnCreateTask" Content="执行一个没有返回值的任务" Click="btnCreateTask_Click_1" Margin="0 10 0 0" />
            <Button Name="btnCancelTask" Content="取消“执行一个没有返回值的任务”" Click="btnCancelTask_Click_1" Margin="0 10 0 0" />
 
            <Button Name="btnCreateTaskWithReturn" Content="执行一个带返回值的任务" Click="btnCreateTaskWithReturn_Click_1" Margin="0 30 0 0" />
            <Button Name="btnCancelTaskWithReturn" Content="取消“执行一个带返回值的任务”" Click="btnCancelTaskWithReturn_Click_1" Margin="0 10 0 0" />
 
        </StackPanel>
    </Grid>
</Page>

Thread/Tasks/TaskDemo.xaml.cs

/*
 * Task - 基于线程池的任务（在 System.Threading.Tasks 命名空间下）
 */
 
using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using System.Threading.Tasks;
using System.Threading;
using Windows.UI.Core;
 
namespace XamlDemo.Thread.Tasks
{
    public sealed partial class TaskDemo : Page
    {
        /*
         * CancellationTokenSource - 用于取消 CancellationToken
         *     Token - 一个 CancellationToken 类型的对象，用于关联 Task
         *     IsCancellationRequested - 是否收到了取消操作的请求
         *     Cancel() - 发出取消操作的请求
         *
         * CancellationToken - 用于关联 Task，以便取消 Task
         *     IsCancellationRequested - 是否收到了取消操作的请求
         *     WaitHandle - 信号，可以通过 WaitHandle.WaitOne() 在当前线程等待
         *     ThrowIfCancellationRequested() - 如果收到了取消操作的请求，则抛出一个 OperationCanceledException 异常
         */
        private CancellationTokenSource _cts;
 
        public TaskDemo()
        {
            this.InitializeComponent();
        }
 
        private void btnCreateTask_Click_1(object sender, RoutedEventArgs e)
        {
            _cts = new CancellationTokenSource();
 
            // 实例化一个 Task，可随时通过 task.Status 获取任务状态
            Task task = new Task(
                (ctx) => // 任务所调用的方法，没有返回值
                {
                    // 在当前线程上阻塞 3000 毫秒（当收到取消请求时会发出信号，停止阻塞）
                    _cts.Token.WaitHandle.WaitOne(3000);
 
                    // 收到取消操作的请求后抛出一个 OperationCanceledException 异常，其会导致 task.IsCanceled 的值变为 true
                    // 此处的代码等同于 _cts.Token.ThrowIfCancellationRequested();
                    if (_cts.IsCancellationRequested)
                        throw new OperationCanceledException(_cts.Token);
                },
                null, // 上下文对象，task.AsyncState 可获取到此对象，上面的 ctx 也可获取到此对象
                _cts.Token // 关联的 CancellationToken 对象，用于取消操作
            );
 
            // 开始执行任务
            task.Start();
            // task.Wait(); 在当前线程上等待任务执行完
            lblMsg.Text = "执行了一个没有返回值的任务，3 秒后执行完毕";
 
            // 任务执行完毕后的处理（注：ContinueWith 方法支持任意次回调，即可以写多个 task.ContinueWith() 都会被回调）
            task.ContinueWith(
                (ctx) => // 任务执行完毕后所调用的方法
                {
                    if (ctx.IsCanceled) // 任务被取消
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "取消了“执行一个没有返回值的任务”";
                            });
                    }
                    if (ctx.IsFaulted) // 任务发生了一个未处理异常
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "“执行一个没有返回值的任务”发生了一个未处理异常";
                            });
                    }
                    if (ctx.IsCompleted) // 任务已完成（任务成功地执行完毕或被取消或发生了未处理异常都会 ctx.IsCompleted == true）
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "“执行一个没有返回值的任务”执行完成，taskId: " + ctx.Id.ToString();
                            });
                    }
                });
        }
 
        private void btnCancelTask_Click_1(object sender, RoutedEventArgs e)
        {
            // 发出取消操作的请求
            _cts.Cancel();
            // _cts.CancelAfter(1000); // 1000 毫秒后发出取消操作的请求
        }
 
        private void btnCreateTaskWithReturn_Click_1(object sender, RoutedEventArgs e)
        {
            _cts = new CancellationTokenSource();
 
            Func<object, string> handler = delegate(object state) // state 是传递过来的上下文对象
            {
                // 在当前线程上阻塞 3000 毫秒（当收到取消请求时会发出信号，停止阻塞）
                _cts.Token.WaitHandle.WaitOne(3000);
 
                // 收到取消操作的请求后抛出一个 OperationCanceledException 异常，其会导致 task.IsCanceled 的值变为 true
                // 此处的代码等同于 _cts.Token.ThrowIfCancellationRequested();
                if (_cts.IsCancellationRequested)
                    throw new OperationCanceledException(_cts.Token);
 
                return "我是“执行一个带返回值的任务”的返回值";
            };
 
            // Task.Factory.StartNew() - 创建任务并马上执行，可随时通过 task.Status 获取任务状态
            // Task.Run() 同样是创建任务并马上执行
            Task<string> task = Task.Factory.StartNew<string>(
                handler, // 任务所调用的方法，带返回值
                null, // 上下文对象，task.AsyncState 可获取到此对象
                _cts.Token // 关联的 CancellationToken 对象，用于取消操作
            );
            lblMsg.Text = "执行了一个带返回值的任务，3 秒后执行完毕";
 
            // 任务执行完毕后的处理（注：ContinueWith 方法支持任意次回调，即可以写多个 task.ContinueWith() 都会被回调）
            task.ContinueWith(
                (ctx) =>
                {
                    if (ctx.IsCanceled) // 任务被取消
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "取消了“执行一个带返回值的任务”";
                            });
                    }
                    if (ctx.IsFaulted) // 任务发生了一个未处理异常
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "“执行一个带返回值的任务”发生了一个未处理异常";
                            });
                    }
                    if (ctx.IsCompleted) // 任务已完成（任务成功地执行完毕或被取消或发生了未处理异常都会 ctx.IsCompleted == true）
                    {
                        var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                lblMsg.Text += "“执行一个带返回值的任务”执行完成，taskId: " + ctx.Id.ToString();
                            });
 
                        // 当任务成功地执行完毕时，输出任务的返回值
                        if (!ctx.IsCanceled && !ctx.IsFaulted)
                        {
                            ignored = Dispatcher.RunAsync(CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg.Text += Environment.NewLine;
                                // 任务的返回值
                                lblMsg.Text += ctx.Result;
                            });
                        }
                    }
                });
        }
 
        private void btnCancelTaskWithReturn_Click_1(object sender, RoutedEventArgs e)
        {
            // 发出取消操作的请求
            _cts.Cancel();
            // _cts.CancelAfter(1000); // 1000 毫秒后发出取消操作的请求
        }
    }
}

2、演示多 Task 的并行执行
Thread/Tasks/MultiTask.xaml

<Page
    x:Class="XamlDemo.Thread.Tasks.MultiTask"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:XamlDemo.Thread.Tasks"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
 
    <Grid Background="Transparent">
        <StackPanel Margin="120 0 0 0">
 
            <TextBlock Name="lblMsg" FontSize="14.667" />
 
            <Button Name="btnCreateMultiTask" Content="任务并行执行" Click="btnCreateMultiTask_Click_1" Margin="0 10 0 0" />
 
        </StackPanel>
    </Grid>
</Page>

Thread/Tasks/MultiTask.xaml.cs

/*
 * 演示多 Task 的并行执行
 *
 * 注：
 * 本例中同时创建了三个任务 task1, task2, task3，但是由于 Task 是基于线程池的，所以三个任务的启动时间是不一样的，启动顺序是不一定的
 * 启动顺序可能是 task1->task2->task3，也可能是 task3->task2->task1，也可能是 task2->task3->task1，等等等等都有可能，是不一定的
 */
 
using System;
using System.Threading.Tasks;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
 
namespace XamlDemo.Thread.Tasks
{
    public sealed partial class MultiTask : Page
    {
        private static int _count = 0;
 
        public MultiTask()
        {
            this.InitializeComponent();
        }
 
        private void btnCreateMultiTask_Click_1(object sender, RoutedEventArgs e)
        {
            // 创建并执行任务1
            Task task1 = Task.Run(
                () =>
                {
                    new System.Threading.ManualResetEvent(false).WaitOne(3000);
                    System.Threading.Interlocked.Increment(ref _count);
                });
            // 创建并执行任务2
            Task task2 = Task.Run(
                () =>
                {
                    new System.Threading.ManualResetEvent(false).WaitOne(3000);
                    System.Threading.Interlocked.Increment(ref _count);
                });
            // 创建并执行任务3
            Task task3 = Task.Run(
               () =>
               {
                   new System.Threading.ManualResetEvent(false).WaitOne(3000);
                   System.Threading.Interlocked.Increment(ref _count);
               });
 
            // 将所有任务合成一个 Task 对象，不会阻塞 UI 线程，通过 task.ContinueWith() 获取结果
            Task task = Task.WhenAll(task1, task2, task3);
            // Task.WaitAll(task1, task2, task3); 等待所有任务完成，会阻塞 UI 线程
 
            DateTime dt = DateTime.Now;
 
            // task 执行完毕后的处理，即所有任务执行完毕后的处理
            task.ContinueWith(
                (ctx) =>
                {
                    var ignored = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High,
                        () =>
                        {
                            lblMsg.Text = "count: " + _count.ToString() + ", 执行时间: " + (DateTime.Now - dt).TotalSeconds.ToString() + "秒";
                        });
                });
        }
    }
}

3、演示 Parallel（并行计算）的基本应用
Thread/Tasks/ParallelDemo.xaml

<Page
    x:Class="XamlDemo.Thread.Tasks.ParallelDemo"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:XamlDemo.Thread.Tasks"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
 
    <Grid Background="Transparent">
        <StackPanel Margin="120 0 0 0">
 
            <TextBlock Name="lblMsg1" FontSize="14.667" />
            <TextBlock Name="lblMsg2" FontSize="14.667" />
 
            <Button Name="btnCreateParallel" Content="执行一个并行运算（Parallel）" Click="btnCreateParallel_Click_1" Margin="0 10 0 0" />
 
            <Button Name="btnCancelParallel" Content="取消" Click="btnCancelParallel_Click_1" Margin="0 10 0 0" />
 
        </StackPanel>
    </Grid>
</Page>

Thread/Tasks/ParallelDemo.xaml.cs

/*
 * Parallel - 并行计算（在 System.Threading.Tasks 命名空间下）
 *
 * Parallel.For() - for 循环的并行运算
 * Parallel.ForEach() - foreach 循环的并行运算
 * Parallel.Invoke() - 并行调用多个 Action
 * PLINQ - LINQ to Object 的并行运算
 *
 *
 * 本例通过 Parallel.Invoke() 来演示并行运算
 * 其它并行运算的说明参见：http://www.cnblogs.com/webabcd/archive/2010/06/03/1750449.html
 */
 
using System.Threading;
using System.Threading.Tasks;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
 
namespace XamlDemo.Thread.Tasks
{
    public sealed partial class ParallelDemo : Page
    {
        private CancellationTokenSource _cts;
 
        public ParallelDemo()
        {
            this.InitializeComponent();
        }
 
        private void btnCreateParallel_Click_1(object sender, RoutedEventArgs e)
        {
            if (_cts != null)
                _cts.Cancel();
            _cts = new CancellationTokenSource();
 
            // Parallel 的相关配置
            ParallelOptions parallelOptions = new ParallelOptions()
            {
                CancellationToken = _cts.Token, // Parallel 关联的 CancellationToken 对象，用于取消操作
                MaxDegreeOfParallelism = 10 // Parallel 的最大并行数
            };
 
            // 并行执行多个 Action（不支持 Func）
            Parallel.Invoke(
                parallelOptions,
                () =>
                    Task1(parallelOptions.CancellationToken),
                () =>
                    Task2(parallelOptions.CancellationToken));
        }
 
        // Action 1
        private void Task1(CancellationToken token)
        {
            Task task = Task.Factory.StartNew(
                () =>
                {
                    int count = 0;
                    // 未被取消则一直运行
                    while (!token.IsCancellationRequested)
                    {
                        count++;
 
                        var ignored = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg1.Text = "count1: " + count.ToString();
                            });
 
                        token.WaitHandle.WaitOne(100);
                    }
                },
                token);
        }
 
        // Action 2
        private void Task2(CancellationToken token)
        {
            Task task = Task.Factory.StartNew(
                () =>
                {
                    int count = 0;
                    // 未被取消则一直运行
                    while (!token.IsCancellationRequested)
                    {
                        count++;
 
                        var ignored = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High,
                            () =>
                            {
                                lblMsg2.Text = "count2: " + count.ToString();
                            });
 
                        token.WaitHandle.WaitOne(100);
                    }
                },
                token);
        }
 
        // 取消并行运算
        private void btnCancelParallel_Click_1(object sender, RoutedEventArgs e)
        {
            if (_cts != null)
                _cts.Cancel();
        }
    }
}