C#并行编程（4）：基于任务的并行

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C#并行编程（4）：基于任务的并行，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5404字，纯文字阅读大概需要8分钟。

内容图文

C#中的任务Task

在C#编程中，实现并行可以直接使用线程，但使用起来很繁琐；也可以使用线程池，线程池很大程度上简化了线程的使用，但是也有着一些局限，比如我们不知道作业什么时候完成，也取不到作业的返回值；解决线程池局限性的方案是使用任务。本文将总结C#中Task的使用。

类似于线程池工作项对异步操作的封装，任务是对异步操作的另一种形式的封装，这种封装抽象层次更高，让我们能够对异步操作进行更多的控制。

任务启动后，通过任务调度器TaskScheduler来调度。.NET中提供两种任务调度器，一种是线程池任务调度器，也是默认调度器，它会将任务派发给线程池工作者线程；另一种是上下文同步任务调度器，它会将任务派发给当前上下文线程，例如GUI线程。此外，我们也能自定义任务调度器，例如可以将异步IO任务派发给线程池IO线程。

Task的使用方法

隐式使用

Parallel静态类除了提供并行循环的各种重载，还提供了一个方法Parallel.Invoke。这个方法可以创建并执行一个或多个异步任务，使用方法如下：

/// <summary>
/// 任务模拟
/// </summary>
private static void DoWork(int workId = 0)
{
    Console.WriteLine($"{DateTime.Now}=> Thread[{Thread.CurrentThread.ManagedThreadId}] started work[{workId}].");
    Thread.Sleep(3000);
    Console.WriteLine($"{DateTime.Now}=> Thread[{Thread.CurrentThread.ManagedThreadId}] done work[{workId}].");
}

/// <summary>
/// 任务的隐式使用
/// </summary>
public static void ImplicitUsingOfTask()
{
    Parallel.Invoke(()=>DoWork(1),()=>DoWork(2),() => DoWork(3));
}

上例的运行结果如下：

2019/3/27 20:40:18=> Thread[9] started work[1].
2019/3/27 20:40:18=> Thread[12] started work[3].
2019/3/27 20:40:18=> Thread[10] started work[2].
2019/3/27 20:40:21=> Thread[9] done work[1].
2019/3/27 20:40:21=> Thread[12] done work[3].
2019/3/27 20:40:21=> Thread[10] done work[2].

对于简单的多任务并行，使用上述的方式很方便，但是这种方式与线程池一样，我们不能控制任务的执行或者获取任务返回值。

显式使用

相对于使用Parallel.Invoke执行并行操作，更常用的是使用Task和Task<T>提供的方法进行异步和并行处理。下面是任务最基本的使用：

Task.Run(() =>
{
    //TODO
});
Task.Factory.StartNew(() =>
{
    //TODO
});

任务的常用操作

获取任务的返回值

具有返回值的任务使用Task<T>,T可根据我们的需求指定，下面是获取任务返回值的方法。

Task<int> task = Task<int>.Factory.StartNew(() =>
{
    Thread.Sleep(3000);//模拟操作用时
    return DateTime.Now.Day;
});
int day = task.Result;

需要说明的是，获取任务的结果会阻塞当前线程。

等待任务完成

有时候，我们需要等待一些任务全部完成后才能执行后续操作，有时候只要多个任务中的一个完成了，就可以执行后续操作。Task提供了Wait、WaitAll和WaitAny等方法满足我们的需求。下面的例子展示了各种等待方法的使用。

/// <summary>
/// 任务等待测试
/// </summary>
public static void TaskWait()
{
    Stopwatch watch = new Stopwatch();

    #region 场景1：等待一个任务完成
    Task task = Task.Run(() => DoWorkOfTask(1000));
    Console.WriteLine("start wait. work duration: 1000");
    watch.Start();
    task.Wait();//等待1秒左右
    watch.Stop();
    Console.WriteLine($"end wait. time: {watch.ElapsedMilliseconds}");
    #endregion

    #region 场景2：等待多个任务完成
    Task[] tasks = new Task[3]
    {
        Task.Run(() => DoWorkOfTask(1000)),
        Task.Run(() => DoWorkOfTask(2000)),
        Task.Run(() => DoWorkOfTask(3000)),
    };

    Console.WriteLine("start wait all. work duration: min 1000 max 3000.");
    watch.Restart();
    Task.WaitAll(tasks);//等待3秒左右
    watch.Stop();
    Console.WriteLine($"end wait. time: {watch.ElapsedMilliseconds}");
    #endregion

    #region 场景3：等待某个任务完成
    tasks = new Task[3]
    {
        Task.Run(() => DoWorkOfTask(1000)),
        Task.Run(() => DoWorkOfTask(2000)),
        Task.Run(() => DoWorkOfTask(3000)),
    };
    Console.WriteLine("start wait any. work duration: min 1000 max 3000.");
    watch.Restart();
    Task.WaitAny(tasks);//等待1秒左右
    watch.Stop();
    Console.WriteLine($"end wait. time: {watch.ElapsedMilliseconds}");
    #endregion
}

/// <summary>
/// 做任务
/// </summary>
/// <param name="workDuration">任务时长</param>
private static void DoWorkOfTask(int workDuration)
{
    Console.WriteLine($"{DateTime.Now}=> Thread[{Thread.CurrentThread.ManagedThreadId}] started task[{Task.CurrentId}].");
    Thread.Sleep(workDuration);
    Console.WriteLine($"{DateTime.Now}=> Thread[{Thread.CurrentThread.ManagedThreadId}] completed task[{Task.CurrentId}].");
}

使用Wait、WaitAll和WaitAny方法时，我们可以设置超时时间或者传入取消Token，以控制等待时间。但这些方法返回布尔值，只能表明是否等待成功；假如我们需要知道所等待的任务返回值，则可以使用WhenAll或WhenAny方法，这两个方法不能控制等待时间，但会返回一个完成的任务。如下例：

Task<int>[] tasks = new Task<int>[3]
{
    Task<int>.Factory.StartNew(() =>
    {
        Console.WriteLine($"task #{Task.CurrentId} run");
        Thread.Sleep(100);
        Console.WriteLine($"task #{Task.CurrentId} done");
        return 100;
    }),
    Task<int>.Factory.StartNew(() =>
    {
        Console.WriteLine($"task #{Task.CurrentId} run");
        Thread.Sleep(500);
        Console.WriteLine($"task #{Task.CurrentId} done");
        return 1000;
    }),
    Task<int>.Factory.StartNew(() =>
    {
        Console.WriteLine($"task #{Task.CurrentId} run");
        Thread.Sleep(1000);
        Console.WriteLine($"task #{Task.CurrentId} done");
        return 10000;
    }),
};

//int[] results = Task.WhenAll(tasks).Result;
//Console.WriteLine($"[{string.Join(",",results)}]");

Task<int> task = Task.WhenAny(tasks).Result;
Console.WriteLine($"task #{task.Id}. result {task.Result}");

Task.WhenAll 和Task.WhenAny在等待结束时，都会创建一个完成状态的任务，WhenAll将等待的所有已完成任务的结果放入创建任务的结果中，WhenAny则将等待的已完成任务放到创建任务的结果中。

任务延续

有时候，我们需要在一个任务完成时开始另一个任务。对于这种需求，我们可以使用Task的ContinueWith等方法来处理。

Task task = Task.Run(() => DoWorkOfTask(3000));
task.ContinueWith(t => DoWorkOfTask(1000));

运行结果：

2019/3/27 21:25:09=> Thread[10] started task[1].

内容总结

以上是互联网集市为您收集整理的C#并行编程（4）：基于任务的并行全部内容，希望文章能够帮你解决C#并行编程（4）：基于任务的并行所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端