澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:的那些事儿,Net异步实例

2019-09-11 作者:www.8455.com   |   浏览(160)

提起异步,Thread,Task,async/await,IAsyncResult 必得领会

C#中 Thread,Task,Async/Await,IAsyncResult 的那一个事情!,

聊起异步,Thread,Task,async/await,IAsyncResult 那几个东西必定是绕不开的,明天就来千家万户聊聊他们

谈起异步,Thread,Task,async/await,IAsyncResult 这几个事物自然是绕不开的,前几天就来家家户户聊聊他们

C#中 Thread,Task,Async/Await,IAsyncResult 的那二个事情!,

谈到异步,Thread,Task,async/await,IAsyncResult 那么些事物一定是绕不开的,前几日就来家家户户聊聊他们

 

1.线程(Thread)

 

四线程的含义在于两个应用程序中,有多少个实行部分可以而且施行;对于比较耗费时间的操作(举个例子io,数据库操作),也许等待响应(如WCF通讯)的操作,能够独自开启后台线程来推行,那样主线程就不会堵塞,能够延续往下实行;等到后台线程实行实现,再通报主线程,然后做出相应操作!

 

在C#中拉开新线程相比简单

 

static void Main(string[] args)
{
    Console.WriteLine("主线程开始");
    //IsBackground=true,将其设置为后台线程
    Thread t = new Thread(Run) { IsBackground = true };
    t.Start();
   Console.WriteLine("主线程在做其他的事!");
    //主线程结束,后台线程会自动结束,不管有没有执行完成
    //Thread.Sleep(300);
    Thread.Sleep(1500);
    Console.WriteLine("主线程结束");
}
static void Run()
{
    Thread.Sleep(700);
    Console.WriteLine("这是后台线程调用");
}

 

举办理并了结果如下图

 

澳门新萄京官方网站 1

 

能够看到在开发银行后台线程之后,主线程继续往下实践了,并不曾等到后台线程施行完事后。

 

说到异步,Thread,Task,async/await,IAsyncResult 这几个事物自然是绕不开的,后天就来家家户户聊聊他们

1.线程(Thread)

三多线程的意思在于多个应用程序中,有多少个实行部分能够并且执行;对于相比较耗费时间的操作(比如io,数据库操作),只怕等待响应(如WCF通讯)的操作,能够单独开启后台线程来举办,那样主线程就不会卡住,能够三番五次往下进行;等到后台线程实行完结,再通报主线程,然后做出相应操作!

在C#中开启新线程相比简单

澳门新萄京官方网站 2

static void Main(string[] args)
{
    Console.WriteLine("主线程开始");
    //IsBackground=true,将其设置为后台线程
    Thread t = new Thread(Run) { IsBackground = true };
    t.Start();
   Console.WriteLine("主线程在做其他的事!");
    //主线程结束,后台线程会自动结束,不管有没有执行完成
    //Thread.Sleep(300);
    Thread.Sleep(1500);
    Console.WriteLine("主线程结束");
}
static void Run()
{
    Thread.Sleep(700);
    Console.WriteLine("这是后台线程调用");
}

澳门新萄京官方网站 3

 施行结果如下图,

澳门新萄京官方网站 4

能够看来在运转后台线程之后,主线程继续往下进行了,并未等到后台线程实践完之后。

1.线程(Thread)

四线程的意义在于一个应用程序中,有多个推行部分能够同一时间试行;对于相比耗费时间的操作(举个例子io,数据库操作),也许等待响应(如WCF通讯)的操作,可以单独开启后台线程来实行,那样主线程就不会卡住,能够持续往下实行;等到后台线程推行实现,再通报主线程,然后做出相应操作!

在C#中开启新线程相比较轻松

static void Main(string[] args)
{
    Console.WriteLine("主线程开始");
    //IsBackground=true,将其设置为后台线程
    Thread t = new Thread(Run) { IsBackground = true };
    t.Start();
   Console.WriteLine("主线程在做其他的事!");
    //主线程结束,后台线程会自动结束,不管有没有执行完成
    //Thread.Sleep(300);
    Thread.Sleep(1500);
    Console.WriteLine("主线程结束");
}
static void Run()
{
    Thread.Sleep(700);
    Console.WriteLine("这是后台线程调用");
}

 推行结果如下图,

澳门新萄京官方网站 5

能够见见在起步后台线程之后,主线程继续往下实行了,并从未等到后台线程推行完现在。

1.线程(Thread)

四线程的意义在于三个应用程序中,有多个实行部分能够同一时间实践;对于比较耗费时间的操作(比方io,数据库操作),或然等待响应(如WCF通讯)的操作,能够单独开启后台线程来实践,那样主线程就不会卡住,可以承继往下实行;等到后台线程奉行完结,再文告主线程,然后做出相应操作!

在C#中拉开新线程比较轻便

static void Main(string[] args)
{
    Console.WriteLine("主线程开始");
    //IsBackground=true,将其设置为后台线程
    Thread t = new Thread(Run) { IsBackground = true };
    t.Start();
   Console.WriteLine("主线程在做其他的事!");
    //主线程结束,后台线程会自动结束,不管有没有执行完成
    //Thread.Sleep(300);
    Thread.Sleep(1500);
    Console.WriteLine("主线程结束");
}
static void Run()
{
    Thread.Sleep(700);
    Console.WriteLine("这是后台线程调用");
}

 实施结果如下图,

澳门新萄京官方网站 6

能够见到在起步后台线程之后,主线程继续往下试行了,并从未等到后台线程实施完事后。

1.1 线程池

 

试想一下,假诺有大气的职责急需管理,譬喻网址后台对于HTTP乞求的拍卖,那是或不是要对每叁个呼吁创造二个后台线程呢?分明不合适,那会占用大批量内存,并且再三地开创的进程也会严重影响速度,那如何是好呢?

 

线程池正是为了缓慢解决这一主题材料,把创立的线程存起来,变成一个线程池(里面有多少个线程),当要拍卖任务时,若线程池中有空闲线程(前二个任务实行到位后,线程不会被回收,会棉被服装置为空闲状态),则直接调用线程池中的线程实践(例asp.net管理机制中的Application对象),使用事例:

 

for (int i = 0; i < 10; i  )
{
    ThreadPool.QueueUserWorkItem(m =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
    });
}
Console.Read();

 

运维结果:

 

澳门新萄京官方网站 7

 

能够见见,即便进行了10回,但并不曾创立十二个线程。

 

1.2 信号量(Semaphore)

 

Semaphore担当和谐线程,能够界定对某一财富访谈的线程数量,这里对SemaphoreSlim类的用法做四个简易的例子:

 

static SemaphoreSlim semLim = new SemaphoreSlim(3); //3表示最多只能有三个线程同时访问
static void Main(string[] args)
{
    for (int i = 0; i < 10; i  )
    {
        new Thread(SemaphoreTest).Start();
    }
    Console.Read();
}
static void SemaphoreTest()
{
    semLim.Wait();
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "开始执行");
    Thread.Sleep(2000);
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "执行完毕");
    semLim.Release();
}

 

实践结果如下:

 

澳门新萄京官方网站 8

 

澳门新萄京官方网站 9

 

能够看看,刚最初唯有多少个线程在实践,当一个线程推行达成并释放之后,才会有新的线程来试行办法!

 

除此而外SemaphoreSlim类,还足以应用Semaphore类,以为更是灵活,感兴趣的话能够搜一下,这里就不做示范了!

 

1.线程(Thread)

八线程的意义在于贰个应用程序中,有多少个实施部分能够相同的时间施行;对于相比较耗费时间的操作(比如io,数据库操作),大概等待响应(如WCF通讯)的操作,可以单独开启后台线程来试行,那样主线程就不会阻塞,能够持续往下进行;等到后台线程实施达成,再公告主线程,然后做出相应操作!

在C#中开启新线程比较简单

static void Main(string[] args)
{
    Console.WriteLine("主线程开始");
    //IsBackground=true,将其设置为后台线程
    Thread t = new Thread(Run) { IsBackground = true };
    t.Start();
   Console.WriteLine("主线程在做其他的事!");
    //主线程结束,后台线程会自动结束,不管有没有执行完成
    //Thread.Sleep(300);
    Thread.Sleep(1500);
    Console.WriteLine("主线程结束");
}
static void Run()
{
    Thread.Sleep(700);
    Console.WriteLine("这是后台线程调用");
}

 实践结果如下图,

澳门新萄京官方网站 10

能够见到在运维后台线程之后,主线程继续往下实行了,并未等到后台线程推行完之后。

1.1 线程池

试想一下,假如有大批量的天职急需管理,比方网址后台对于HTTP诉求的拍卖,那是或不是要对每一种乞求成立五个后台线程呢?分明不合适,这会攻克大批量内部存款和储蓄器,何况数次地成立的进程也会严重影响进程,那如何做呢?线程池便是为着化解这一标题,把成立的线程存起来,产生二个线程池(里面有五个线程),当要拍卖任务时,若线程池中有闲暇线程(前多个职务执行到位后,线程不会被回收,会棉被服装置为空闲状态),则平素调用线程池中的线程实践(例asp.net管理体制中的Application对象),

行使事例:

澳门新萄京官方网站 11

for (int i = 0; i < 10; i  )
{
    ThreadPool.QueueUserWorkItem(m =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
    });
}
Console.Read();

澳门新萄京官方网站 12

运转结果:

澳门新萄京官方网站 13

能够看来,纵然施行了10回,但并不曾开创十二个线程。

1.1 线程池

试想一下,倘诺有恢宏的天职急需管理,譬如网址后台对于HTTP诉求的拍卖,那是否要对每二个哀告创制四个后台线程呢?明显不合适,那会占有大批量内存,何况往往地创制的进度也会严重影响速度,那如何是好呢?线程池正是为了消除这一标题,把创设的线程存起来,产生多少个线程池(里面有五个线程),当要管理义务时,若线程池中有空闲线程(前一个职分施行到位后,线程不会被回收,会被设置为空闲状态),则间接调用线程池中的线程试行(例asp.net管理机制中的Application对象),

运用事例:

for (int i = 0; i < 10; i  )
{
    ThreadPool.QueueUserWorkItem(m =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
    });
}
Console.Read();

运作结果:

澳门新萄京官方网站 14

能够观看,即使实行了12回,但并从未成立十二个线程。

1.1 线程池

试想一下,假如有雅量的职责急需管理,举个例子网址后台对于HTTP乞请的拍卖,那是否要对每八个呼吁创设二个后台线程呢?显著不合适,这会占用大批量内部存款和储蓄器,並且频频地开创的经过也会严重影响进程,这如何是好呢?线程池便是为了消除这一主题素材,把成立的线程存起来,形成多个线程池(里面有多少个线程),当要管理职责时,若线程池中有空闲线程(前一个职分实行到位后,线程不会被回收,会被装置为空闲状态),则间接调用线程池中的线程实行(例asp.net管理机制中的Application对象),

运用事例:

for (int i = 0; i < 10; i  )
{
    ThreadPool.QueueUserWorkItem(m =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
    });
}
Console.Read();

运维结果:

澳门新萄京官方网站 15

能够看看,纵然实施了12回,但并从未开创12个线程。

2.Task

 

Task是.NET4.0加入的,跟线程池ThreadPool的功用周边,用Task开启新职分时,会从线程池中调用线程,而Thread每一遍实例化都会创立三个新的线程。

 

Console.WriteLine("主线程启动");
//Task.Run启动一个线程
//Task启动的是后台线程,要在主线程中等待后台线程执行完毕,可以调用Wait方法
//Task task = Task.Factory.StartNew(() => { Thread.Sleep(1500); Console.WriteLine("task启动"); });
Task task = Task.Run(() => { 
    Thread.Sleep(1500);
    Console.WriteLine("task启动");
});
Thread.Sleep(300);
task.Wait();
Console.WriteLine("主线程结束");

 

实行结果如下:

 

澳门新萄京官方网站 16

 

开启新义务的章程:Task.Run()恐怕Task.Factory.StartNew(),开启的是后台线程要在主线程中等待后台线程推行实现,能够利用Wait方法(会以联合的不二等秘书技来实施)。不用Wait则会以异步的格局来执行。

 

正如一下Task和Thread:

 

static void Main(string[] args)
{
    for (int i = 0; i < 5; i  )
    {
        new Thread(Run1).Start();
    }
    for (int i = 0; i < 5; i  )
    {
        Task.Run(() => { Run2(); });
    }
}
static void Run1()
{
    Console.WriteLine("Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}
static void Run2()
{
    Console.WriteLine("Task调用的Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}

 

施行结果:

 

澳门新萄京官方网站 17

 

可以看出来,直接用Thread会开启5个线程,用Task(用了线程池)开启了3个!

 

1.1 线程池

试想一下,假使有雅量的职分急需管理,举个例子网址后台对于HTTP央求的拍卖,那是还是不是要对每贰个伸手成立几个后台线程呢?鲜明不合适,那会攻下多量内部存款和储蓄器,并且往往地创设的历程也会严重影响进程,那怎么做呢?线程池就是为了缓慢解决这一主题材料,把创设的线程存起来,变成三个线程池(里面有多个线程),当要拍卖任务时,若线程池中有空余线程(前一个职分实施到位后,线程不会被回收,会被安装为空闲状态),则平素调用线程池中的线程实践(例asp.net管理机制中的Application对象),

行使事例:

for (int i = 0; i < 10; i  )
{
    ThreadPool.QueueUserWorkItem(m =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
    });
}
Console.Read();

运营结果:

澳门新萄京官方网站 18

能够观察,固然实行了十三回,但并不曾创制12个线程。

 1.2 信号量(Semaphore)

 Semaphore负责和谐线程,能够限制对某一财富采访的线程数量

 这里对SemaphoreSlim类的用法做贰个简练的例证:

澳门新萄京官方网站 19

static SemaphoreSlim semLim = new SemaphoreSlim(3); //3表示最多只能有三个线程同时访问
static void Main(string[] args)
{
    for (int i = 0; i < 10; i  )
    {
        new Thread(SemaphoreTest).Start();
    }
    Console.Read();
}
static void SemaphoreTest()
{
    semLim.Wait();
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "开始执行");
    Thread.Sleep(2000);
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "执行完毕");
    semLim.Release();
}

澳门新萄京官方网站 20

推行结果如下:

澳门新萄京官方网站 21澳门新萄京官方网站 22

能够观望,刚开端唯有多个线程在实行,当一个线程推行实现并释放之后,才会有新的线程来实行措施!

除此而外SemaphoreSlim类,还是能够动用塞马phore类,感到越是灵敏,感兴趣的话能够搜一下,这里就不做示范了!

 1.2 信号量(Semaphore)

 塞马phore肩负和谐线程,能够限制对某一财富访问的线程数量

 这里对SemaphoreSlim类的用法做一个轻松的事例:

static SemaphoreSlim semLim = new SemaphoreSlim(3); //3表示最多只能有三个线程同时访问
static void Main(string[] args)
{
    for (int i = 0; i < 10; i  )
    {
        new Thread(SemaphoreTest).Start();
    }
    Console.Read();
}
static void SemaphoreTest()
{
    semLim.Wait();
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "开始执行");
    Thread.Sleep(2000);
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "执行完毕");
    semLim.Release();
}

施行结果如下:

澳门新萄京官方网站 23澳门新萄京官方网站 24

能够观望,刚先导独有八个线程在实行,当一个线程实践完成并释放之后,才会有新的线程来实行格局!

除了那个之外SemaphoreSlim类,还是能运用Semaphore类,感觉越来越灵敏,感兴趣的话能够搜一下,这里就不做示范了!

 1.2 信号量(Semaphore)

 塞马phore负担和煦线程,可以限制对某一能源访谈的线程数量

 这里对SemaphoreSlim类的用法做贰个简约的例子:

static SemaphoreSlim semLim = new SemaphoreSlim(3); //3表示最多只能有三个线程同时访问
static void Main(string[] args)
{
    for (int i = 0; i < 10; i  )
    {
        new Thread(SemaphoreTest).Start();
    }
    Console.Read();
}
static void SemaphoreTest()
{
    semLim.Wait();
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "开始执行");
    Thread.Sleep(2000);
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "执行完毕");
    semLim.Release();
}

推行结果如下:

澳门新萄京官方网站 25澳门新萄京官方网站 26

能够见到,刚起先唯有八个线程在实践,当一个线程试行实现并释放之后,才会有新的线程来试行办法!

除了SemaphoreSlim类,还足以利用塞马phore类,认为更是灵活,感兴趣的话可以搜一下,这里就不做示范了!

2.1 Task<TResult>

 

Task<TResult>正是有再次回到值的Task,TResult正是回到值类型。

 

Console.WriteLine("主线程开始");
//返回值类型为string
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到task执行完毕才会输出;
Console.WriteLine(task.Result);
Console.WriteLine("主线程结束");

 

运作结果:

 

澳门新萄京官方网站 27

 

通过task.Result可以取到重返值,若取值的时候,后台线程还没试行完,则会等待其实行完结!

 

一句话来讲提一下:

 

Task职责能够因而CancellationTokenSource类来撤销,感到用得非常少,用法比较轻松,感兴趣的话能够搜一下!

 

 1.2 信号量(Semaphore)

 Semaphore担当和谐线程,能够限制对某一财富访问的线程数量

 这里对SemaphoreSlim类的用法做叁个轻便易行的事例:

static SemaphoreSlim semLim = new SemaphoreSlim(3); //3表示最多只能有三个线程同时访问
static void Main(string[] args)
{
    for (int i = 0; i < 10; i  )
    {
        new Thread(SemaphoreTest).Start();
    }
    Console.Read();
}
static void SemaphoreTest()
{
    semLim.Wait();
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "开始执行");
    Thread.Sleep(2000);
    Console.WriteLine("线程"   Thread.CurrentThread.ManagedThreadId.ToString()   "执行完毕");
    semLim.Release();
}

施行结果如下:

澳门新萄京官方网站 28澳门新萄京官方网站 29

能够看来,刚初阶独有八个线程在实行,当三个线程实行完成并释放之后,才会有新的线程来施行格局!

除此而外SemaphoreSlim类,还能使用塞马phore类,感到越来越灵敏,感兴趣的话可以搜一下,这里就不做示范了!

2.Task

Task是.NET4.0投入的,跟线程池ThreadPool的机能类似,用Task开启新职分时,会从线程池中调用线程,而Thread每趟实例化都会创设三个新的线程。

澳门新萄京官方网站 30

Console.WriteLine("主线程启动");
//Task.Run启动一个线程
//Task启动的是后台线程,要在主线程中等待后台线程执行完毕,可以调用Wait方法
//Task task = Task.Factory.StartNew(() => { Thread.Sleep(1500); Console.WriteLine("task启动"); });
Task task = Task.Run(() => { 
    Thread.Sleep(1500);
    Console.WriteLine("task启动");
});
Thread.Sleep(300);
task.Wait();
Console.WriteLine("主线程结束");

澳门新萄京官方网站 31

实行结果如下:

澳门新萄京官方网站 32

敞开新义务的艺术:Task.Run()只怕Task.Factory.StartNew(),开启的是后台线程

要在主线程中等待后台线程执行完成,可以运用Wait方法(会以协同的点子来实施)。不用Wait则会以异步的主意来施行。

正如一下Task和Thread:

澳门新萄京官方网站 33

static void Main(string[] args)
{
    for (int i = 0; i < 5; i  )
    {
        new Thread(Run1).Start();
    }
    for (int i = 0; i < 5; i  )
    {
        Task.Run(() => { Run2(); });
    }
}
static void Run1()
{
    Console.WriteLine("Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}
static void Run2()
{
    Console.WriteLine("Task调用的Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}

澳门新萄京官方网站 34

实施结果:

澳门新萄京官方网站 35

能够看出来,直接用Thread会开启5个线程,用Task(用了线程池)开启了3个!

2.Task

Task是.NET4.0步入的,跟线程池ThreadPool的效应相近,用Task开启新任务时,会从线程池中调用线程,而Thread每一回实例化都会创制四个新的线程。

Console.WriteLine("主线程启动");
//Task.Run启动一个线程
//Task启动的是后台线程,要在主线程中等待后台线程执行完毕,可以调用Wait方法
//Task task = Task.Factory.StartNew(() => { Thread.Sleep(1500); Console.WriteLine("task启动"); });
Task task = Task.Run(() => { 
    Thread.Sleep(1500);
    Console.WriteLine("task启动");
});
Thread.Sleep(300);
task.Wait();
Console.WriteLine("主线程结束");

试行结果如下:

澳门新萄京官方网站 36

张开新职分的点子:Task.Run()恐怕Task.Factory.StartNew(),开启的是后台线程

要在主线程中等待后台线程试行完结,能够应用Wait方法(会以协同的格局来实施)。不用Wait则会以异步的方法来试行。

正如一下Task和Thread:

static void Main(string[] args)
{
    for (int i = 0; i < 5; i  )
    {
        new Thread(Run1).Start();
    }
    for (int i = 0; i < 5; i  )
    {
        Task.Run(() => { Run2(); });
    }
}
static void Run1()
{
    Console.WriteLine("Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}
static void Run2()
{
    Console.WriteLine("Task调用的Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}

施行结果:

澳门新萄京官方网站 37

能够看出来,直接用Thread会开启5个线程,用Task(用了线程池)开启了3个!

2.Task

Task是.NET4.0参与的,跟线程池ThreadPool的效劳类似,用Task开启新任务时,会从线程池中调用线程,而Thread每趟实例化都会成立三个新的线程。

Console.WriteLine("主线程启动");
//Task.Run启动一个线程
//Task启动的是后台线程,要在主线程中等待后台线程执行完毕,可以调用Wait方法
//Task task = Task.Factory.StartNew(() => { Thread.Sleep(1500); Console.WriteLine("task启动"); });
Task task = Task.Run(() => { 
    Thread.Sleep(1500);
    Console.WriteLine("task启动");
});
Thread.Sleep(300);
task.Wait();
Console.WriteLine("主线程结束");

实践结果如下:

澳门新萄京官方网站 38

翻开新职分的格局:Task.Run()只怕Task.Factory.StartNew(),开启的是后台线程

要在主线程中等待后台线程实施达成,能够行使Wait方法(会以四只的秘籍来进行)。不用Wait则会以异步的章程来实施。

比较一下Task和Thread:

static void Main(string[] args)
{
    for (int i = 0; i < 5; i  )
    {
        new Thread(Run1).Start();
    }
    for (int i = 0; i < 5; i  )
    {
        Task.Run(() => { Run2(); });
    }
}
static void Run1()
{
    Console.WriteLine("Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}
static void Run2()
{
    Console.WriteLine("Task调用的Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}

施行结果:

澳门新萄京官方网站 39

能够看出来,直接用Thread会开启5个线程,用Task(用了线程池)开启了3个!

3. async/await

 

async/await是C#5.0中出产的,先上用法:

 

static void Main(string[] args)
{
    Console.WriteLine("-------主线程启动-------");
    Task<int> task = GetStrLengthAsync();
    Console.WriteLine("主线程继续执行");
    Console.WriteLine("Task返回的值"   task.Result);
    Console.WriteLine("-------主线程结束-------");
}
static async Task<int> GetStrLengthAsync()
{
    Console.WriteLine("GetStrLengthAsync方法开始执行");
    //此处返回的<string>中的字符串类型,而不是Task<string>
    string str = await GetString();
    Console.WriteLine("GetStrLengthAsync方法执行结束");
    return str.Length;
}
static Task<string> GetString()
{
   //Console.WriteLine("GetString方法开始执行")
    return Task<string>.Run(() =>
    {
        Thread.Sleep(2000);
        return "GetString的返回值";
    });
}

 

async用来修饰方法,注脚那个艺术是异步的,证明的方法的回到类型必需为:void,Task或Task<TResult>。

 

await必需用来修饰Task或Task<TResult>,况且不得不出现在早已用async关键字修饰的异步方法中。常常状态下,async/await成对出现才有含义,看看运转结果:

 

澳门新萄京官方网站 40

 

能够看出来,main函数调用GetStrLengthAsync方法后,在await在此以前,都以一起进行的,直到碰到await关键字,main函数才回去继续试行。

 

那正是说是或不是是在遇到await关键字的时候程序自动开启了八个后台线程去施行GetString方法呢?

 

近日把GetString方法中的那行注释加上,运营的结果是:

 

澳门新萄京官方网站 41

 

我们能够看来,在蒙受await关键字后,未有继续实行GetStrLengthAsync方法前面包车型地铁操作,也并未有应声反回到main函数中,而是实行了GetString的首先行,以此能够确定await这里并不曾拉开新的线程去施行GetString方法,而是以联合的点子让GetString方法推行,等到施行到GetString方法中的Task<string>.Run()的时候才由Task开启了后台线程!

 

那正是说await的功效是何等吧?

 

能够从字面上精通,上边提到task.wait能够让主线程等待后台线程实践达成,await和wait类似,一样是伺机,等待Task<string>.Run()起头的后台线程推行实现,差异的是await不会卡住主线程,只会让GetStrLengthAsync方法暂停试行。

 

那便是说await是怎么形成的啊?有未有张开新线程去等待?

 

澳门新萄京官方网站 42

 

唯有五个线程(主线程和Task开启的线程)!至于怎么完结的(笔者也不知道......>_<),我们有意思味的话研商下吧!

 

2.Task

Task是.NET4.0参预的,跟线程池ThreadPool的效果与利益看似,用Task开启新职务时,会从线程池中调用线程,而Thread每便实例化都会创立三个新的线程。

Console.WriteLine("主线程启动");
//Task.Run启动一个线程
//Task启动的是后台线程,要在主线程中等待后台线程执行完毕,可以调用Wait方法
//Task task = Task.Factory.StartNew(() => { Thread.Sleep(1500); Console.WriteLine("task启动"); });
Task task = Task.Run(() => { 
    Thread.Sleep(1500);
    Console.WriteLine("task启动");
});
Thread.Sleep(300);
task.Wait();
Console.WriteLine("主线程结束");

实行结果如下:

澳门新萄京官方网站 43

翻开新任务的形式:Task.Run()也许Task.Factory.StartNew(),开启的是后台线程

要在主线程中等待后台线程施行完结,可以应用Wait方法(会以三头的章程来进行)。不用Wait则会以异步的措施来实行。

正如一下Task和Thread:

static void Main(string[] args)
{
    for (int i = 0; i < 5; i  )
    {
        new Thread(Run1).Start();
    }
    for (int i = 0; i < 5; i  )
    {
        Task.Run(() => { Run2(); });
    }
}
static void Run1()
{
    Console.WriteLine("Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}
static void Run2()
{
    Console.WriteLine("Task调用的Thread Id ="   Thread.CurrentThread.ManagedThreadId);
}

执行结果:

澳门新萄京官方网站 44

可以看出来,直接用Thread会开启5个线程,用Task(用了线程池)开启了3个!

2.1 Task<TResult>

Task<TResult>正是有重回值的Task,TResult正是回到值类型。

澳门新萄京官方网站 45

Console.WriteLine("主线程开始");
//返回值类型为string
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到task执行完毕才会输出;
Console.WriteLine(task.Result);
Console.WriteLine("主线程结束");

澳门新萄京官方网站 46

运营结果:

澳门新萄京官方网站 47

通过task.Result能够取到重回值,若取值的时候,后台线程还没执行完,则会等待其实行完毕!

简易提一下:

Task职责能够由此CancellationTokenSource类来撤销,以为用得没多少,用法比较轻巧,感兴趣的话可以搜一下!

2.1 Task<TResult>

Task<TResult>正是有再次回到值的Task,TResult正是再次来到值类型。

Console.WriteLine("主线程开始");
//返回值类型为string
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到task执行完毕才会输出;
Console.WriteLine(task.Result);
Console.WriteLine("主线程结束");

运行结果:

澳门新萄京官方网站 48

经过task.Result可以取到重回值,若取值的时候,后台线程还没施行完,则会等待其实践达成!

简言之提一下:

Task职务能够通过CancellationTokenSource类来撤销,感到用得相当少,用法相比较轻易,感兴趣的话能够搜一下!

2.1 Task<TResult>

Task<TResult>就是有重回值的Task,TResult正是回来值类型。

Console.WriteLine("主线程开始");
//返回值类型为string
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到task执行完毕才会输出;
Console.WriteLine(task.Result);
Console.WriteLine("主线程结束");

运作结果:

澳门新萄京官方网站 49

透过task.Result能够取到重回值,若取值的时候,后台线程还没实施完,则会等待其实行达成!

大概提一下:

Task职务能够经过CancellationTokenSource类来裁撤,感到用得非常的少,用法相比较轻巧,感兴趣的话能够搜一下!

4.IAsyncResult

 

IAsyncResult自.NET1.1起就有了,蕴含可异步操作的主意的类必要贯彻它,Task类就落到实处了该接口

 

 

澳门新萄京官方网站 50

 

在不借助Task的景观下怎么落到实处异步呢?

 

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主程序开始--------------------");
        int threadId;
        AsyncDemo ad = new AsyncDemo();
        AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);
 
        IAsyncResult result = caller.BeginInvoke(3000,out threadId, null, null);
        Thread.Sleep(0);
        Console.WriteLine("主线程线程 {0} 正在运行.",Thread.CurrentThread.ManagedThreadId)
        //会阻塞线程,直到后台线程执行完毕之后,才会往下执行
        result.AsyncWaitHandle.WaitOne();
        Console.WriteLine("主程序在做一些事情!!!");
        //获取异步执行的结果
        string returnValue = caller.EndInvoke(out threadId, result);
        //释放资源
        result.AsyncWaitHandle.Close();
        Console.WriteLine("主程序结束--------------------");
        Console.Read();
    }
}
public class AsyncDemo
{
    //供后台线程执行的方法
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("测试方法开始执行.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return String.Format("测试方法执行的时间 {0}.", callDuration.ToString());
    }
}
public delegate string AsyncMethodCaller(int callDuration, out int threadId);

 

关键步骤正是黄褐字体的有个别,运营结果:

 

澳门新萄京官方网站 51

 

和Task的用法差异不是非常大!result.AsyncWaitHandle.WaitOne()就就像Task的Wait。

 

5.Parallel

 

最终说一下在循环中拉开多线程的大概方法:

 

Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int i = 1; i <= 10; i  )
{
    Console.Write(i   ",");
    Thread.Sleep(1000);
}
watch1.Stop();
Console.WriteLine(watch1.Elapsed);
Stopwatch watch2 = new Stopwatch();
watch2.Start();
//会调用线程池中的线程
Parallel.For(1, 11, i =>
{
    Console.WriteLine(i   ",线程ID:"   Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(1000);
});
watch2.Stop();
Console.WriteLine(watch2.Elapsed);

 

运行结果:

 

澳门新萄京官方网站 52

 

循环List<T>:

 

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 6, 7, 8, 9 };
Parallel.ForEach<int>(list, n =>
{
    Console.WriteLine(n);
    Thread.Sleep(1000);
});

 

执行Action[]数组里面包车型客车法子:

 

Action[] actions = new Action[] { 
   new Action(()=>{
       Console.WriteLine("方法1");
   }),
    new Action(()=>{
       Console.WriteLine("方法2");
   })
};
Parallel.Invoke(actions);

2.1 Task<TResult>

Task<TResult>正是有重临值的Task,TResult便是重临值类型。

Console.WriteLine("主线程开始");
//返回值类型为string
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到task执行完毕才会输出;
Console.WriteLine(task.Result);
Console.WriteLine("主线程结束");

运作结果:

澳门新萄京官方网站 53

通过task.Result能够取到重临值,若取值的时候,后台线程还没实行完,则会等待其进行实现!

总结提一下:

Task任务能够由此CancellationTokenSource类来撤销,认为用得没有多少,用法相比较轻松,感兴趣的话能够搜一下!

 3. async/await

async/await是C#5.0中生产的,先上用法:

澳门新萄京官方网站 54

static void Main(string[] args)
{
    Console.WriteLine("-------主线程启动-------");
    Task<int> task = GetStrLengthAsync();
    Console.WriteLine("主线程继续执行");
    Console.WriteLine("Task返回的值"   task.Result);
    Console.WriteLine("-------主线程结束-------");
}

static async Task<int> GetStrLengthAsync()
{
    Console.WriteLine("GetStrLengthAsync方法开始执行");
    //此处返回的<string>中的字符串类型,而不是Task<string>
    string str = await GetString();
    Console.WriteLine("GetStrLengthAsync方法执行结束");
    return str.Length;
}

static Task<string> GetString()
{
   //Console.WriteLine("GetString方法开始执行")
    return Task<string>.Run(() =>
    {
        Thread.Sleep(2000);
        return "GetString的返回值";
    });
}

澳门新萄京官方网站 55

async用来修饰方法,申明那些主意是异步的,申明的办法的归来类型必需为:void,Task或Task<TResult>。

await必需用来修饰Task或Task<TResult>,并且只好出现在已经用async关键字修饰的异步方法中。经常情形下,async/await成对出现才有意义,

看看运营结果:

澳门新萄京官方网站 56

能够看出来,main函数调用GetStrLengthAsync方法后,在await在此以前,都以同台试行的,直到碰到await关键字,main函数才回来继续实践。

那么是或不是是在蒙受await关键字的时候程序自动开启了三个后台线程去实行GetString方法吗?

当今把GetString方法中的那行注释加上,运维的结果是:

澳门新萄京官方网站 57

世家能够看看,在遭逢await关键字后,未有继续实践GetStrLengthAsync方法前面包车型大巴操作,也未尝立即反回到main函数中,而是进行了GetString的率先行,以此能够料定await这里并从未开启新的线程去推行GetString方法,而是以协同的章程让GetString方法实施,等到实施到GetString方法中的Task<string>.Run()的时候才由Task开启了后台线程!

那正是说await的机能是何等吗?

能够从字面上理解,下边提到task.wait能够让主线程等待后台线程施行完结,await和wait类似,同样是伺机,等待Task<string>.Run()开头的后台线程实施达成,区别的是await不会阻塞主线程,只会让GetStrLengthAsync方法暂停实施。

那么await是怎么办到的呢?有未有张开新线程去等待?

澳门新萄京官方网站 58

独有多个线程(主线程和Task开启的线程)!至于怎么形成的(作者也不知道......>_<),大家有意思味的话商量下吧!

 3. async/await

async/await是C#5.0中出产的,先上用法:

static void Main(string[] args)
{
    Console.WriteLine("-------主线程启动-------");
    Task<int> task = GetStrLengthAsync();
    Console.WriteLine("主线程继续执行");
    Console.WriteLine("Task返回的值"   task.Result);
    Console.WriteLine("-------主线程结束-------");
}

static async Task<int> GetStrLengthAsync()
{
    Console.WriteLine("GetStrLengthAsync方法开始执行");
    //此处返回的<string>中的字符串类型,而不是Task<string>
    string str = await GetString();
    Console.WriteLine("GetStrLengthAsync方法执行结束");
    return str.Length;
}

static Task<string> GetString()
{
   //Console.WriteLine("GetString方法开始执行")
    return Task<string>.Run(() =>
    {
        Thread.Sleep(2000);
        return "GetString的返回值";
    });
}

async用来修饰方法,声明那些点子是异步的,注脚的艺术的回到类型必得为:void,Task或Task<TResult>。

await必须用来修饰Task或Task<TResult>,况且只可以出现在早就用async关键字修饰的异步方法中。经常状态下,async/await成对出现才有意义,

拜见运转结果:

澳门新萄京官方网站 59

可以看出来,main函数调用GetStrLengthAsync方法后,在await从前,都以同台实行的,直到遇见await关键字,main函数才重回继续试行。

那正是说是或不是是在遇到await关键字的时候程序自动开启了二个后台线程去推行GetString方法吧?

当今把GetString方法中的那行注释加上,运营的结果是:

澳门新萄京官方网站 60

我们能够见见,在遇到await关键字后,未有继续试行GetStrLengthAsync方法前面包车型大巴操作,也一直不即时反回到main函数中,而是进行了GetString的首先行,以此可以剖断await这里并不曾拉开新的线程去实施GetString方法,而是以共同的方法让GetString方法试行,等到施行到GetString方法中的Task<string>.Run()的时候才由Task开启了后台线程!

那么await的功力是何等啊?

能够从字面上明白,上面提到task.wait能够让主线程等待后台线程推行完结,await和wait类似,一样是等待,等待Task<string>.Run()开始的后台线程实行完成,区别的是await不会卡住主线程,只会让GetStrLengthAsync方法暂停实行。

这正是说await是怎么形成的吗?有未有张开新线程去等待?

澳门新萄京官方网站 61

唯有多个线程(主线程和Task开启的线程)!至于怎么完结的(作者也不知道......>_<),大家风野趣的话研商下呢!

 3. async/await

async/await是C#5.0中推出的,先上用法:

static void Main(string[] args)
{
    Console.WriteLine("-------主线程启动-------");
    Task<int> task = GetStrLengthAsync();
    Console.WriteLine("主线程继续执行");
    Console.WriteLine("Task返回的值"   task.Result);
    Console.WriteLine("-------主线程结束-------");
}

static async Task<int> GetStrLengthAsync()
{
    Console.WriteLine("GetStrLengthAsync方法开始执行");
    //此处返回的<string>中的字符串类型,而不是Task<string>
    string str = await GetString();
    Console.WriteLine("GetStrLengthAsync方法执行结束");
    return str.Length;
}

static Task<string> GetString()
{
   //Console.WriteLine("GetString方法开始执行")
    return Task<string>.Run(() =>
    {
        Thread.Sleep(2000);
        return "GetString的返回值";
    });
}

async用来修饰方法,申明那个办法是异步的,证明的办法的回来类型必需为:void,Task或Task<TResult>。

await必需用来修饰Task或Task<TResult>,何况不得不出现在曾经用async关键字修饰的异步方法中。平常情况下,async/await成对出现才有含义,

会见运营结果:

澳门新萄京官方网站 62

能够看出来,main函数调用GetStrLengthAsync方法后,在await在此以前,都以联合签字施行的,直到境遇await关键字,main函数才回到继续推行。

那么是或不是是在遇见await关键字的时候程序自动开启了贰个后台线程去试行GetString方法呢?

这段日子把GetString方法中的那行注释加上,运转的结果是:

澳门新萄京官方网站 63

世家能够观看,在遇见await关键字后,没有继续施行GetStrLengthAsync方法前边的操作,也未曾登时反回到main函数中,而是进行了GetString的第一行,以此能够判明await这里并未展开新的线程去推行GetString方法,而是以联合的诀要让GetString方法施行,等到推行到GetString方法中的Task<string>.Run()的时候才由Task开启了后台线程!

那正是说await的意义是怎么吧?

能够从字面上明白,上边提到task.wait能够让主线程等待后台线程施行完结,await和wait类似,一样是伺机,等待Task<string>.Run()开端的后台线程推行达成,分歧的是await不会堵塞主线程,只会让GetStrLengthAsync方法暂停实行。

那么await是怎么办到的吧?有未有打开新线程去等待?

澳门新萄京官方网站 64

唯有三个线程(主线程和Task开启的线程)!至于怎么造成的(我也不知道......>_<),我们有野趣的话商量下啊!

 

 3. async/await

async/await是C#5.0中生产的,先上用法:

static void Main(string[] args)
{
    Console.WriteLine("-------主线程启动-------");
    Task<int> task = GetStrLengthAsync();
    Console.WriteLine("主线程继续执行");
    Console.WriteLine("Task返回的值"   task.Result);
    Console.WriteLine("-------主线程结束-------");
}

static async Task<int> GetStrLengthAsync()
{
    Console.WriteLine("GetStrLengthAsync方法开始执行");
    //此处返回的<string>中的字符串类型,而不是Task<string>
    string str = await GetString();
    Console.WriteLine("GetStrLengthAsync方法执行结束");
    return str.Length;
}

static Task<string> GetString()
{
   //Console.WriteLine("GetString方法开始执行")
    return Task<string>.Run(() =>
    {
        Thread.Sleep(2000);
        return "GetString的返回值";
    });
}

async用来修饰方法,阐明那个法子是异步的,注解的措施的归来类型必得为:void,Task或Task<TResult>。

await必需用来修饰Task或Task<TResult>,并且不得不出现在已经用async关键字修饰的异步方法中。经常状态下,async/await成对出现才有含义,

探问运维结果:

澳门新萄京官方网站 65

能够看出来,main函数调用GetStrLengthAsync方法后,在await在此以前,都以一块施行的,直到遇到await关键字,main函数才回去继续实践。

这就是说是还是不是是在碰着await关键字的时候程序自动开启了叁个后台线程去实践GetString方法吗?

今昔把GetString方法中的那行注释加上,运转的结果是:

澳门新萄京官方网站 66

世家能够见到,在碰到await关键字后,没有继续实行GetStrLengthAsync方法前面包车型地铁操作,也并没有立时反回到main函数中,而是举办了GetString的首先行,以此可以看清await这里并不曾拉开新的线程去推行GetString方法,而是以协同的格局让GetString方法推行,等到实践到GetString方法中的Task<string>.Run()的时候才由Task开启了后台线程!

那么await的职能是怎样吗?

能够从字面上驾驭,上边提到task.wait能够让主线程等待后台线程实施实现,await和wait类似,同样是等待,等待Task<string>.Run()初始的后台线程施行完结,不一样的是await不会阻塞主线程,只会让GetStrLengthAsync方法暂停实践。

那就是说await是如何做到的吧?有未有张开新线程去等待?

澳门新萄京官方网站 67

唯有八个线程(主线程和Task开启的线程)!至于怎么实现的(小编也不知道......>_<),大家有意思味的话探究下吧!

4.IAsyncResult

IAsyncResult自.NET1.1起就有了,包涵可异步操作的不二秘技的类供给实现它,Task类就落到实处了该接口

澳门新萄京官方网站 68

在不正视Task的处境下怎么落到实处异步呢?

澳门新萄京官方网站 69

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主程序开始--------------------");
        int threadId;
        AsyncDemo ad = new AsyncDemo();
        AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

        IAsyncResult result = caller.BeginInvoke(3000,out threadId, null, null);
        Thread.Sleep(0);
        Console.WriteLine("主线程线程 {0} 正在运行.",Thread.CurrentThread.ManagedThreadId)
        //会阻塞线程,直到后台线程执行完毕之后,才会往下执行
        result.AsyncWaitHandle.WaitOne();
        Console.WriteLine("主程序在做一些事情!!!");
        //获取异步执行的结果
        string returnValue = caller.EndInvoke(out threadId, result);
        //释放资源
        result.AsyncWaitHandle.Close();
        Console.WriteLine("主程序结束--------------------");
        Console.Read();
    }
}
public class AsyncDemo
{
    //供后台线程执行的方法
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("测试方法开始执行.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return String.Format("测试方法执行的时间 {0}.", callDuration.ToString());
    }
}
public delegate string AsyncMethodCaller(int callDuration, out int threadId);

澳门新萄京官方网站 70

关键步骤正是红棕字体的一部分,运转结果:

澳门新萄京官方网站 71

和Task的用法差别不是异常的大!result.AsyncWaitHandle.WaitOne()就就像Task的Wait。

4.IAsyncResult

IAsyncResult自.NET1.1起就有了,包罗可异步操作的办法的类要求贯彻它,Task类就贯彻了该接口

澳门新萄京官方网站 72

在不依赖Task的情状下怎么落到实处异步呢?

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主程序开始--------------------");
        int threadId;
        AsyncDemo ad = new AsyncDemo();
        AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

        IAsyncResult result = caller.BeginInvoke(3000,out threadId, null, null);
        Thread.Sleep(0);
        Console.WriteLine("主线程线程 {0} 正在运行.",Thread.CurrentThread.ManagedThreadId)
        //会阻塞线程,直到后台线程执行完毕之后,才会往下执行
        result.AsyncWaitHandle.WaitOne();
        Console.WriteLine("主程序在做一些事情!!!");
        //获取异步执行的结果
        string returnValue = caller.EndInvoke(out threadId, result);
        //释放资源
        result.AsyncWaitHandle.Close();
        Console.WriteLine("主程序结束--------------------");
        Console.Read();
    }
}
public class AsyncDemo
{
    //供后台线程执行的方法
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("测试方法开始执行.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return String.Format("测试方法执行的时间 {0}.", callDuration.ToString());
    }
}
public delegate string AsyncMethodCaller(int callDuration, out int threadId);

关键步骤就是革命字体的片段,运营结果:

澳门新萄京官方网站 73

和Task的用法差距不是十分大!result.AsyncWaitHandle.WaitOne()就恍如Task的Wait。

4.IAsyncResult

IAsyncResult自.NET1.1起就有了,满含可异步操作的章程的类供给实现它,Task类就兑现了该接口

澳门新萄京官方网站 74

在不依赖Task的意况下怎么落到实处异步呢?

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主程序开始--------------------");
        int threadId;
        AsyncDemo ad = new AsyncDemo();
        AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

        IAsyncResult result = caller.BeginInvoke(3000,out threadId, null, null);
        Thread.Sleep(0);
        Console.WriteLine("主线程线程 {0} 正在运行.",Thread.CurrentThread.ManagedThreadId)
        //会阻塞线程,直到后台线程执行完毕之后,才会往下执行
        result.AsyncWaitHandle.WaitOne();
        Console.WriteLine("主程序在做一些事情!!!");
        //获取异步执行的结果
        string returnValue = caller.EndInvoke(out threadId, result);
        //释放资源
        result.AsyncWaitHandle.Close();
        Console.WriteLine("主程序结束--------------------");
        Console.Read();
    }
}
public class AsyncDemo
{
    //供后台线程执行的方法
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("测试方法开始执行.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return String.Format("测试方法执行的时间 {0}.", callDuration.ToString());
    }
}
public delegate string AsyncMethodCaller(int callDuration, out int threadId);

关键步骤就是新民主主义革命字体的局地,运营结果:

澳门新萄京官方网站 75

和Task的用法差距不是非常的大!result.AsyncWaitHandle.WaitOne()就就好像Task的Wait。

6.异步的回调

 

为了简洁(偷懒),文中全数Task<TResult>的再次回到值都是平素用task.result获取,那样就算后台任务未有实行完成的话,主线程会等待其推行实现。那样的话就和协同一样了,一般意况下不会这样用。轻巧演示一下Task回调函数的接纳:

 

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到任务执行完之后执行
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
Console.WriteLine("主线程结束");
Console.Read();

 

实行结果:

 

澳门新萄京官方网站 76

 

OnCompleted中的代码会在职分推行到位之后施行!

 

其余task.孔蒂nueWith()也是三个主要的章程:

 

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
task.ContinueWith(m=>{Console.WriteLine("第一个任务结束啦!我是第二个任务");});
Console.WriteLine("主线程结束");
Console.Read();

 

实践结果:

 

澳门新萄京官方网站 77

 

ContinueWith()方法能够让该后台线程继续实施新的义务。

 

Task的运用依然相比较灵敏的,我们能够商量下,好了,以上正是全体内容了,篇幅和力量都有数,希望对大家有用!

Thread,Task,Async/Await,IAsyncResult 的那么些事情!, 聊到异步,Thread,Task,async/await,IAsyncResult 那几个东西自然是绕不开的,明天就来依次...

4.IAsyncResult

IAsyncResult自.NET1.1起就有了,富含可异步操作的诀窍的类须求贯彻它,Task类就落实了该接口

澳门新萄京官方网站 78

在不借助Task的情形下怎么落到实处异步呢?

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主程序开始--------------------");
        int threadId;
        AsyncDemo ad = new AsyncDemo();
        AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

        IAsyncResult result = caller.BeginInvoke(3000,out threadId, null, null);
        Thread.Sleep(0);
        Console.WriteLine("主线程线程 {0} 正在运行.",Thread.CurrentThread.ManagedThreadId)
        //会阻塞线程,直到后台线程执行完毕之后,才会往下执行
        result.AsyncWaitHandle.WaitOne();
        Console.WriteLine("主程序在做一些事情!!!");
        //获取异步执行的结果
        string returnValue = caller.EndInvoke(out threadId, result);
        //释放资源
        result.AsyncWaitHandle.Close();
        Console.WriteLine("主程序结束--------------------");
        Console.Read();
    }
}
public class AsyncDemo
{
    //供后台线程执行的方法
    public string TestMethod(int callDuration, out int threadId)
    {
        Console.WriteLine("测试方法开始执行.");
        Thread.Sleep(callDuration);
        threadId = Thread.CurrentThread.ManagedThreadId;
        return String.Format("测试方法执行的时间 {0}.", callDuration.ToString());
    }
}
public delegate string AsyncMethodCaller(int callDuration, out int threadId);

关键步骤正是浅紫字体的有的,运营结果:

澳门新萄京官方网站 79

和Task的用法差距不是一点都不小!result.AsyncWaitHandle.WaitOne()就就像是Task的Wait。

 5.Parallel

最终说一下在循环中开启二十八线程的回顾方法:

澳门新萄京官方网站 80

Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int i = 1; i <= 10; i  )
{
    Console.Write(i   ",");
    Thread.Sleep(1000);
}
watch1.Stop();
Console.WriteLine(watch1.Elapsed);

Stopwatch watch2 = new Stopwatch();
watch2.Start();

//会调用线程池中的线程
Parallel.For(1, 11, i =>
{
    Console.WriteLine(i   ",线程ID:"   Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(1000);
});
watch2.Stop();
Console.WriteLine(watch2.Elapsed);

澳门新萄京官方网站 81

运行结果:

澳门新萄京官方网站 82

循环List<T>:

澳门新萄京官方网站 83

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 6, 7, 8, 9 };
Parallel.ForEach<int>(list, n =>
{
    Console.WriteLine(n);
    Thread.Sleep(1000);
});

澳门新萄京官方网站 84

执行Action[]数组里面包车型地铁办法:

澳门新萄京官方网站 85

Action[] actions = new Action[] { 
   new Action(()=>{
       Console.WriteLine("方法1");
   }),
    new Action(()=>{
       Console.WriteLine("方法2");
   })
};
Parallel.Invoke(actions);

澳门新萄京官方网站 86

 5.Parallel

澳门新萄京官方网站:的那些事儿,Net异步实例讲解。最后说一下在循环中展开二十二十四线程的简便方法:

Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int i = 1; i <= 10; i  )
{
    Console.Write(i   ",");
    Thread.Sleep(1000);
}
watch1.Stop();
Console.WriteLine(watch1.Elapsed);

Stopwatch watch2 = new Stopwatch();
watch2.Start();

//会调用线程池中的线程
Parallel.For(1, 11, i =>
{
    Console.WriteLine(i   ",线程ID:"   Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(1000);
});
watch2.Stop();
Console.WriteLine(watch2.Elapsed);

运行结果:

澳门新萄京官方网站 87

循环List<T>:

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 6, 7, 8, 9 };
Parallel.ForEach<int>(list, n =>
{
    Console.WriteLine(n);
    Thread.Sleep(1000);
});

执行Action[]数组里面包车型客车格局:

Action[] actions = new Action[] { 
   new Action(()=>{
       Console.WriteLine("方法1");
   }),
    new Action(()=>{
       Console.WriteLine("方法2");
   })
};
Parallel.Invoke(actions);

 5.Parallel

终极说一下在循环中拉开多线程的简约方法:

Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int i = 1; i <= 10; i  )
{
    Console.Write(i   ",");
    Thread.Sleep(1000);
}
watch1.Stop();
Console.WriteLine(watch1.Elapsed);

Stopwatch watch2 = new Stopwatch();
watch2.Start();

//会调用线程池中的线程
Parallel.For(1, 11, i =>
{
    Console.WriteLine(i   ",线程ID:"   Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(1000);
});
watch2.Stop();
Console.WriteLine(watch2.Elapsed);

运维结果:

澳门新萄京官方网站 88

循环List<T>:

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 6, 7, 8, 9 };
Parallel.ForEach<int>(list, n =>
{
    Console.WriteLine(n);
    Thread.Sleep(1000);
});

执行Action[]数组里面包车型大巴秘诀:

Action[] actions = new Action[] { 
   new Action(()=>{
       Console.WriteLine("方法1");
   }),
    new Action(()=>{
       Console.WriteLine("方法2");
   })
};
Parallel.Invoke(actions);

 5.Parallel

最后说一下在循环中开启二十四线程的大致方法:

Stopwatch watch1 = new Stopwatch();
watch1.Start();
for (int i = 1; i <= 10; i  )
{
    Console.Write(i   ",");
    Thread.Sleep(1000);
}
watch1.Stop();
Console.WriteLine(watch1.Elapsed);

Stopwatch watch2 = new Stopwatch();
watch2.Start();

//会调用线程池中的线程
Parallel.For(1, 11, i =>
{
    Console.WriteLine(i   ",线程ID:"   Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(1000);
});
watch2.Stop();
Console.WriteLine(watch2.Elapsed);

运作结果:

澳门新萄京官方网站 89

循环List<T>:

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 6, 7, 8, 9 };
Parallel.ForEach<int>(list, n =>
{
    Console.WriteLine(n);
    Thread.Sleep(1000);
});

执行Action[]数组里面包车型地铁办法:

Action[] actions = new Action[] { 
   new Action(()=>{
       Console.WriteLine("方法1");
   }),
    new Action(()=>{
       Console.WriteLine("方法2");
   })
};
Parallel.Invoke(actions);

6.异步的回调

文中全体Task<TResult>的再次回到值都以一向用task.result获取,那样假诺后台职分未有实施完成的话,主线程会等待其实行实现,这样的话就和同步同样了(看上去同样,但骨子里await的时候并不会促成线程的堵塞,web程序感到不到,可是wpf,winform这样的桌面程序若不利用异步,会导致UI线程的隔绝)。轻易演示一下Task回调函数的利用:

澳门新萄京官方网站 90

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到任务执行完之后执行
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
Console.WriteLine("主线程结束");
Console.Read();

澳门新萄京官方网站 91

施行结果:

澳门新萄京官方网站 92

OnCompleted中的代码会在任务实施到位以后实施!

另外task.ContinueWith()也是一个重大的诀窍:

澳门新萄京官方网站 93

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});

task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
task.ContinueWith(m=>{Console.WriteLine("第一个任务结束啦!我是第二个任务");});
Console.WriteLine("主线程结束");
Console.Read();

澳门新萄京官方网站 94

施行结果:

澳门新萄京官方网站 95

ContinueWith()方法能够让该后台线程继续实行新的天职。

6.异步的回调

为了简洁(偷懒),文中全体Task<TResult>的重临值都是间接用task.result获取,这样要是后台职责未有推行完成的话,主线程会等待其实行完结。那样的话就和一齐一样了,一般景观下不会如此用。简单演示一下Task回调函数的施用:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到任务执行完之后执行
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
Console.WriteLine("主线程结束");
Console.Read();

推行结果:

澳门新萄京官方网站 96

OnCompleted中的代码会在职分推行到位以往施行!

其余task.ContinueWith()也是二个第一的不二等秘书技:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});

task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
task.ContinueWith(m=>{Console.WriteLine("第一个任务结束啦!我是第二个任务");});
Console.WriteLine("主线程结束");
Console.Read();

实施结果:

澳门新萄京官方网站 97

ContinueWith()方法能够让该后台线程继续实施新的职务。

Task的行使大概比较灵敏的,我们能够研讨下,好了,以上正是全体内容了,篇幅和技艺都轻巧,希望对大家有用!

 

Thread,Task,Async/Await,IAsyncResult 的那么些事儿!, 聊起异步,Thread,Task,async/await,IAsyncResult 这几个事物自然是绕不开的,明日就来依次...

6.异步的回调

文中全数Task<TResult>的重返值都以一向用task.result获取,那样假诺后台职务未有进行完成的话,主线程会等待其施行实现,那样的话就和一道同样了(看上去一样,但实在await的时候并不会变成线程的短路,web程序感到不到,不过wpf,winform那样的桌面程序若不选取异步,会招致UI线程的封堵)。轻易演示一下Task回调函数的行使:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到任务执行完之后执行
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
Console.WriteLine("主线程结束");
Console.Read();

推行结果:

澳门新萄京官方网站 98

OnCompleted中的代码会在职务执行到位之后实行!

别的task.ContinueWith()也是二个要害的措施:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});

task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
task.ContinueWith(m=>{Console.WriteLine("第一个任务结束啦!我是第二个任务");});
Console.WriteLine("主线程结束");
Console.Read();

施行结果:

澳门新萄京官方网站 99

ContinueWith()方法能够让该后台线程继续推行新的任务。

Task的应用还是比较灵敏的,大家能够研商下,好了,以上正是全体内容了,篇幅和力量都有数,希望对我们有用!

 

6.异步的回调

文中全体Task<TResult>的再次回到值都以间接用task.result获取,那样一旦后台职分未有推行达成的话,主线程会等待其试行完成,那样的话就和一块同样了(看上去同样,但事实上await的时候并不会导致线程的围堵,web程序认为不到,可是wpf,winform那样的桌面程序若不接纳异步,会促成UI线程的堵塞)。轻便演示一下Task回调函数的选用:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});
//会等到任务执行完之后执行
task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
Console.WriteLine("主线程结束");
Console.Read();

进行结果:

澳门新萄京官方网站 100

OnCompleted中的代码会在义务实践到位今后试行!

其余task.孔蒂nueWith()也是贰个尤为重要的方法:

Console.WriteLine("主线程开始");
Task<string> task = Task<string>.Run(() => {
    Thread.Sleep(2000); 
    return Thread.CurrentThread.ManagedThreadId.ToString(); 
});

task.GetAwaiter().OnCompleted(() =>
{
    Console.WriteLine(task.Result);
});
task.ContinueWith(m=>{Console.WriteLine("第一个任务结束啦!我是第二个任务");});
Console.WriteLine("主线程结束");
Console.Read();

实践结果:

澳门新萄京官方网站 101

ContinueWith()方法能够让该后台线程继续试行新的天职。

Task的行使可能相比灵活的,我们能够研讨下,好了,以上就是全体内容了,篇幅和技艺都有限,希望对大家有用!

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:的那些事儿,Net异步实例

关键词: