多线程编程学习笔记——async和await(一),示例代码如下

接上文 三十二线程编程学习笔记——async和await(一)

接上文 三十二线程编程学习笔记——async和await(一)

三、  
对连日的异步任务选择await操作符

三、  
对连日的异步任务使用await操作符

      
本示例学习怎么着阅读有三个await方法措施时,程序的莫过于流程是怎么着的,精通await的异步调用

      
本示例学习怎么样阅读有几个await方法格局时,程序的莫过于流程是什么样的,精通await的异步调用

1。示例代码如下。

1。示例代码如下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {
        static void Main(string[] args)
        {
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {
        static void Main(string[] args)
        {

 Console.WriteLine(string.Format(“—–
对接二连三的异步职务使用await操作符—-“));

 Console.WriteLine(string.Format(“—–
对两次三番的异步任务使用await操作符—-“));

            Task t = AsyncWithTPL();
            t.Wait();
            t = AsyncWithAwait();
            t.Wait();
            Console.Read();          
        }



        static Task AsyncWithTPL()
        {
            var containerTask = new Task(() =>
            {
                Task<string> task1 = GetInfoAsync("TPL Task 1");

                task1.ContinueWith(task =>
                {
                    Console.WriteLine(task1.Result);

                    Task<string> task2 = GetInfoAsync("TPL Task 2");
                    task2.ContinueWith(innerTask =>
              Console.WriteLine(innerTask.Result), TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);

                    task2.ContinueWith(innerTask =>
Console.WriteLine(innerTask.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent); 

                }, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);
                task1.ContinueWith(task =>
              Console.WriteLine(task1.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
            }
            );
            containerTask.Start();
            return containerTask;
        }
        async static Task AsyncWithAwait()
        {
            try
            {
                string result = await GetInfoAsync("Async Task 1");
                Console.WriteLine(result);
                 result = await GetInfoAsync("Async Task 2");
                Console.WriteLine(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        async static Task<string> GetInfoAsync(string name)
        {
            Console.WriteLine(string.Format("任务 {0} 开始。。。",name));
            await Task.Delay(TimeSpan.FromSeconds(2));
            if(name== "TPL Task 2")
            throw new Exception(string.Format("{0} 抛出异常信息!", name));
            return string.Format(" Task {0} 正在运行在线程 ID={1}上。这个工作线程是否是线程池中的线程:{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}
            Task t = AsyncWithTPL();
            t.Wait();
            t = AsyncWithAwait();
            t.Wait();
            Console.Read();          
        }



        static Task AsyncWithTPL()
        {
            var containerTask = new Task(() =>
            {
                Task<string> task1 = GetInfoAsync("TPL Task 1");

                task1.ContinueWith(task =>
                {
                    Console.WriteLine(task1.Result);

                    Task<string> task2 = GetInfoAsync("TPL Task 2");
                    task2.ContinueWith(innerTask =>
              Console.WriteLine(innerTask.Result), TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);

                    task2.ContinueWith(innerTask =>
Console.WriteLine(innerTask.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent); 

                }, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);
                task1.ContinueWith(task =>
              Console.WriteLine(task1.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
            }
            );
            containerTask.Start();
            return containerTask;
        }
        async static Task AsyncWithAwait()
        {
            try
            {
                string result = await GetInfoAsync("Async Task 1");
                Console.WriteLine(result);
                 result = await GetInfoAsync("Async Task 2");
                Console.WriteLine(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        async static Task<string> GetInfoAsync(string name)
        {
            Console.WriteLine(string.Format("任务 {0} 开始。。。",name));
            await Task.Delay(TimeSpan.FromSeconds(2));
            if(name== "TPL Task 2")
            throw new Exception(string.Format("{0} 抛出异常信息!", name));
            return string.Format(" Task {0} 正在运行在线程 ID={1}上。这个工作线程是否是线程池中的线程:{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

 

 

 2.程序运行结果,如下图。

 2.程序运行结果,如下图。

 ca88亚洲城官网 1

 ca88亚洲城官网 2

       
首先,程序运行时会执行多个异步操作。

       
首先,程序运行时会执行多个异步操作。

  1. AsyncWithAwait方法,它看起来跟日常的代码一样,唯一不一致之处就是行使了八个await评释。最要害的一些是代码的实践种种如故是种种执行的,调用AsyncWithAwait职务的代码唯有等
    以前的的职务到位
    后才会最先履行。当阅读代码时,程序流很清楚,可以看来什么样先实施,什么后实施,不过程序如何异步执可以吗?首先,它不是一向是异步执行的,唯有当使用await,且一个职务现已到位,我们会异步地得到这一个任务的结果。否则
    ,当在代码中看看await注明时,通过的行为是代码执行到await代码行时将霎时赶回,并且剩下的代码将会在一个后续操作义务中运行。由此等待操作结果时并没有阻塞程序执行,这是一个异步调用
    。当AsyncWithAwait方法中的代码执行时,除了在main方法中调用
    t.wait外,我们得以实施任务其余任务。可是主线程必须等待直到所有的异步操作完成,否则 主线程完成后具备运行异步操作的后台线程会为止运行。
  2. AsyncWithTPL方法模仿了AsyncWithAwait的程序流。我们须求一个器皿任务来拍卖所有互相依赖的任务。然后启动主职务,给其加了一组后续操作。当这些职务到位
    后,会打印其结果。然后又开动了一个职务,在那一个职责成功后会依次运行越多的一连操作。为了测试对非常的拍卖,当运行第四个义务时有意抛出了一个不胜。并打印出更加音信。那组后续操作创制了与第四个措施中千篇一律的程序流。
  1. AsyncWithAwait方法,它看起来跟日常的代码一样,唯一差别之处就是选拔了几个await评释。最重大的某些是代码的进行各样依然是逐一执行的,调用AsyncWithAwait义务的代码唯有等
    从前的的义务到位
    后才会发轫执行。当阅读代码时,程序流很清楚,可以看来什么样先实施,什么后实施,然则程序如何异步执行呢?首先,它不是平素是异步执行的,唯有当使用await,且一个职责现已做到,大家会异步地得到那么些任务的结果。否则
    ,当在代码中见到await声明时,通过的行事是代码执行到await代码行时将马上赶回,并且剩下的代码将会在一个后续操作任务中运行。因而等待操作结果时并从未阻塞程序执行,那是一个异步调用
    。当AsyncWithAwait方法中的代码执行时,除了在main方法中调用
    t.wait外,我们得以实施任务其他职分。可是主线程必须等待直到所有的异步操作达成,否则 主线程完毕后有所运行异步操作的后台线程会停止运作。
  2. AsyncWithTPL方法模仿了AsyncWithAwait的程序流。大家必要一个器皿任务来处理所有相互信赖的任务。然后启动主义务,给其加了一组后续操作。当以此义务到位
    后,会打印其结果。然后又开动了一个职务,在这么些义务成功后会依次运行越来越多的三番四遍操作。为了测试对充裕的拍卖,当运行第一个任务时有意抛出了一个非凡。并打印出卓殊音讯。那组后续操作创立了与第二个措施中一致的程序流。

二、  
对并行执行的异步义务选择await操作符

二、  
对并行执行的异步职责使用await操作符

        
本示例学习怎么使用await来并行地运行异步职责,而不应用常规使用各种执行措施。

        
本示例学习怎样使用await来并行地运行异步职责,而不使用常规使用各种执行措施。

 1.演示代码如下。

ca88亚洲城官网, 1.演示代码如下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine(string.Format("-----    对并行执行的异步任务使用await操作符----"));
            Task t = AsyncProcess();
            t.Wait();      
            Console.Read();           

        }

        async static Task AsyncProcess()
        {

            Task<string> task1 = GetInfoAsync("Task 1",3);        

                Task<string> task2 = GetInfoAsync("Task 2",5);
            string[] results = await Task.WhenAll(task1, task2);
            foreach (var item in results)
            {
                Console.WriteLine(item);
            }
        }

        async static Task<string> GetInfoAsync(string name,int second)
        {
            Console.WriteLine(string.Format("任务 {0} 开始。。。",name));

            await Task.Delay(TimeSpan.FromSeconds(second));
            //await Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(second));
            return string.Format(" Task {0} 正在运行在线程 ID={1}上。这个工作线程是否是线程池中的线程:{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine(string.Format("-----    对并行执行的异步任务使用await操作符----"));
            Task t = AsyncProcess();
            t.Wait();      
            Console.Read();           

        }

        async static Task AsyncProcess()
        {

            Task<string> task1 = GetInfoAsync("Task 1",3);        

                Task<string> task2 = GetInfoAsync("Task 2",5);
            string[] results = await Task.WhenAll(task1, task2);
            foreach (var item in results)
            {
                Console.WriteLine(item);
            }
        }

        async static Task<string> GetInfoAsync(string name,int second)
        {
            Console.WriteLine(string.Format("任务 {0} 开始。。。",name));

            await Task.Delay(TimeSpan.FromSeconds(second));
            //await Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(second));
            return string.Format(" Task {0} 正在运行在线程 ID={1}上。这个工作线程是否是线程池中的线程:{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

 

 

 2.程序运行结果,如下图。

 2.程序运行结果,如下图。

 ca88亚洲城官网 3

 ca88亚洲城官网 4

       在AsyncProcess方法中定义了多个异步义务task1,task2,分别运行3秒和5秒。然后使用Task.WhenAll支持格局得到了三个职责的运转结果,而且惟有在具备底层义务到位以后,才会运行。之后大家拭目以待这几个组成义务的结果。5秒后,大家得到具有结果,表达了那么些职责是还要运行的。

       在AsyncProcess方法中定义了五个异步职务task1,task2,分别运行3秒和5秒。然后接纳Task.WhenAll接济形式拿到了多个义务的运作结果,而且唯有在所有底层任务到位未来,才会运作。之后大家拭目以待这几个组合任务的结果。5秒后,我们收获具有结果,表明了这一个职务是同时运转的。

      
大家精心观察会发现,那五个职分假托是被线程池中的同一个干活线程执行的。当我们互动运行任务时怎么可能暴发那样的气象吗?我们诠释掉GetIntroAsync方法中的await
Task.Delay代码 行,并清除对await
task.run代码行的笺注,然后重新运行程序。

      
大家精心观望会发现,那多个职分假托是被线程池中的同一个工作线程执行的。当我们互动运行职务时怎么可能爆发如此的情景吧?我们诠释掉GetIntroAsync方法中的await
Task.Delay代码 行,并免去对await
task.run代码行的表明,然后再次运行程序。

      
大家会看出那种景色下,八个职分会被不一致的行事线程执行。不一样之处是task.delay在捻脚捻手使用了一个计时器,进程如下:从线程池中得到工作线程,它将等待task.delay方法重回结果。然后task.delay方法启动计时器并指定一段代码,那段代码会在计时器时间到了task.delay方法中指定的秒数后被
调用
,之后,立刻将工作线程重临到线程池中。当计时器事件运行时,又从线程池中肆意获取一个可用的干活线程(可能跟上次运行的是同一个工作线程),并运行计时器指定的代码。

      
大家会看到那种场所下,四个职务会被分裂的工作线程执行。差异之处是task.delay在悄悄使用了一个计时器,进程如下:从线程池中得到工作线程,它将等待task.delay方法再次来到结果。然后task.delay方法启动计时器并点名一段代码,那段代码会在计时器时间到了task.delay方法中指定的秒数后被
调用
,之后,马上将工作线程重回到线程池中。当计时器事件运行时,又从线程池中肆意获取一个可用的行事线程(可能跟上次运作的是同一个工作线程),并运行计时器指定的代码。

         
当使用task.run方法时,从线程池中获取了一个干活线程并将其阻塞几秒,然后拿走了第一个办事线程也将其阻塞。在那种处境下,大家成本了四个工作线程,不过怎么工作也没做。如下图。相比两者的分化之处,在于多少个task运行在不一致的线程上。

         
当使用task.run方法时,从线程池中得到了一个做事线程并将其阻塞几秒,然后拿走了第一个干活线程也将其阻塞。在这种气象下,大家开销了五个工作线程,然而怎么工作也没做。如下图。相比两者的分歧之处,在于五个task运行在不一致的线程上。

 ca88亚洲城官网 5

 ca88亚洲城官网 6

 

 

相关文章