义务并行库,多线程编制程序学习笔记

接上文 二十八线程编制程序学习笔记——基础(一)

接上文 二十四线程编制程序学习笔记——基础

 接上文 四线程编制程序学习笔记——基础(二)

接上文 二十四线程编制程序学习笔记——基础

 接上文 四线程编制程序学习笔记——基础(三)

接上文 四线程编制程序学习笔记——基础

 接上文 四线程编制程序学习笔记——线程同步(1)

接上文四线程编制程序学习笔记——线程同步

 接上文 四线程编制程序学习笔记——线程同步(二)

接上文 二十多线程编制程序学习笔记——线程同步

  接上文 10二线程编制程序学习笔记——线程同步(三)

接上文 八线程编制程序学习笔记——线程同步

接上文
四线程编制程序学习笔记——线程池(1)

接上文
拾2线程编制程序学习笔记——线程池

接上文 八线程编程学习笔记——线程池(2)

接上文 二1010二线程编制程序学习笔记——线程池

 接上文 多线程编制程序学习笔记——线程池(叁)

接上文八线程编制程序学习笔记——线程池

     

前方我们上学了怎么是线程,线程之间的一块,使用线程池。使用线程池能够削减我们大批量短期操作的竞相线程所用的操作系统财富。

      
前边大家学习了什么是线程,线程之间的壹块儿,使用线程池。使用线程池能够减小大家大批量短期操作的竞相线程所用的操作系统能源。

在net framework
四.0中微软又提供了3个新的异步操作的成效,叫做职务并行库。任务并行库的基本是任务。1个职分代表了二个异步操作,譔操作能够通过三种格局运营,能够行使或不采用独立的线程。

       在net framework
肆.0中微软又提供了二个新的异步操作的职能,叫做职责并行库(TPL)。职务并行库的着力是职责(task)。二个职分代表了三个异步操作,譔操作能够通过各个艺术运维,可以应用或不使用独立的线程。

1个职务能够透过多样主意和别的职分组合起来使用。例如,能够而且拉开七个职分,等待全部职务到位,再起多个职务进展操作。贰个任务能够有几个别的职务组成,这么些义务也得以依次拥有和谐的子职务。

       
四个职务(Task)能够透过两种主意和其他职务组合起来使用。例如,能够而且拉开七个任务,等待全体任务到位,再起二个任务进展操作。3个任务能够有八个其余职务组成,那些任务也得以依次拥有和谐的子义务。

C#5.0及之后的本子都曾经放手了对TPL的支撑,允许大家利用await与async关键字展开任务执行。

        
C#5.0及以后的本子都早就放手了对TPL的支撑,允许我们利用await与async关键字展开义务执行。

以下示例,大家使用.Net Framework
四.5后头版本。

         以下示例,大家使用.Net
Framework 肆.5自此版本。

1、 创制职责

 

下边包车型大巴示范,大家利用task构造函数创设了五个职务。大家传入了二个lambda表明式做为操作职责。然后接纳start运行职分。

壹、   成立职责

接着,大家应用task.Run和task.startNew方法来运转八个职责。与行使task构造函数分裂之处,在于那多少个被创造的职分会立时执行。所以不用显式地调用
那么些职责的Start方法。从task1到task4全数职责都以放在线程池中推行的,数十次进行,能够发现执行各样是区别等的。

       
上面包车型客车言传身教,大家应用task构造函数创立了五个职责。大家传入了一个lambda表达式做为操作职分。然后接纳start运行职责。

Task5,由于我们标记为了长日子运作,所以是1个独立的线程,不是线程池中的线程来运营的。

       
接着,咱们选用task.Run和task.startNew方法来运维多少个职分。与使用task构造函数差异之处,在于那两个被创设的职分会立刻实施。所以不必显式地调用
这个职务的Start方法。从task一到task四全部职责都以放在线程池中实践的,数10遍履行,能够发现执行各种是不均等的。

  1. 代码如下:

         
Task5,由于大家标记为了长日子运作,所以是3个单身的线程,不是线程池中的线程来运维的。

  1. 代码如下:
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks; namespace ThreadTPLDemo{    class Program    {        static void Main(string[] args)        {            Console.WriteLine("Task 运行示例 ————{0}",DateTime.Now);           var task1 = new Task => TaskOper("Task1"));            var task2 = new Task => TaskOper("Task2"));            task1.Start();            task2.Start();                       Task.Factory.StartNew => TaskOper("Task 3"));Task.Run => TaskOper("Task 4"));             //长时间运行            Task.Factory.StartNew => TaskOper("Task 5"),TaskCreationOptions.LongRunning);                      Thread.Sleep(1000);            Console.ReadKey();        }        private static void TaskOper(string  name)        {                       Console.WriteLine("Task 运行在 线程 ID:{0} 上,这个线程是不是线程池中的线程:{1},名称: {2}",            Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsThreadPoolThread, name);         }    }} 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks; 

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

            Console.WriteLine("Task 运行示例 ————{0}",DateTime.Now);

           var task1 = new Task(() => TaskOper("Task1"));
            var task2 = new Task(() => TaskOper("Task2"));
            task1.Start();
            task2.Start();           

            Task.Factory.StartNew(() => TaskOper("Task 3"));
Task.Run(() => TaskOper("Task 4")); 

            //长时间运行
            Task.Factory.StartNew(() => TaskOper("Task 5"),TaskCreationOptions.LongRunning);
                      Thread.Sleep(1000);
            Console.ReadKey();
        }
        private static void TaskOper(string  name)
        {           

            Console.WriteLine("Task 运行在 线程 ID:{0} 上,这个线程是不是线程池中的线程:{1},名称: {2}",            Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsThreadPoolThread, name); 

        }
    }
}

二.运行结果如下图。作者把程序运行了一次。请自行查看差别之处。

 

图片 1

 二.运营结果如下图。笔者把程序运维了一次。请自行查看区别之处。

贰、 使用职分履行基本的操作

图片 2

本示例是从任务中取得结果值。大家透过差别的实施结果来呈以往线程池中实践与在主线程中实践的分歧之处。

 

  1. 代码如下:

    using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks; namespace ThreadTPLDemo{ class Program { static void Main(string[] args) { Console.WriteLine(“Task 基本操作 ————”); TaskOper(“—-主线程Task运营”); Task task一 =CreateTask(“Task1″); task1.Start(); string result = task一.Result; Console.WriteLine(” 运转结果——{0}”, result); Task task二 = CreateTask(“Task二”); task二.RunSynchronously(); result = task一.Result; Console.WriteLine(” 运维结果——{0}”, result); Task task3 = CreateTask(“Task3″); task3.Start(); while(!task三.IsCompleted) { Console.WriteLine(” 状态——{0}”, task三.Status); Thread.Sleep(500); } Console.WriteLine(” ——状态—{0}”, task三.Status); result = task3.Result; Console.WriteLine(” 运行结果——{0}”, result); Console.ReadKey(); } private static string TaskOper(string name) { Console.WriteLine(“Task 线程 ID:{0} 上,是还是不是线程池中的线程:{一},名称: {二}”, Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsThreadPoolThread, name); Thread.Sleep(三千); return string.Format(“线程ID:{0},名称:{1}”, Thread.CurrentThread.ManagedThreadId,name); } static Task CreateTask(string name) { return new Task => TaskOper; } }}

二、   使用职责履行基本的操作

二.程序运转结果如下图。

        
本示例是从职分中获得结果值。大家经过不一样的履行结果来展现在线程池中执行与在主线程中执行的分化之处。

图片 3

 一. 代码如下:

率先直接运转TaskOper方法,依据程序运行结果,大家能够领略那些点子是被同步执行的。

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

namespace ThreadTPLDemo
{

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Task 基本操作 ————");
            TaskOper("----主线程Task运行");

           Task<string> task1 =CreateTask("Task1");
            task1.Start();
            string result = task1.Result;
            Console.WriteLine(" 运行结果——{0}", result); 

            Task<string> task2 = CreateTask("Task2");
            task2.RunSynchronously();
            result = task1.Result;
            Console.WriteLine(" 运行结果——{0}", result); 

            Task<string> task3 = CreateTask("Task3");
            task3.Start();
          while(!task3.IsCompleted)
            {
                Console.WriteLine(" 状态——{0}", task3.Status);
                Thread.Sleep(500);
            }

            Console.WriteLine(" ——状态—{0}", task3.Status);
            result = task3.Result;
            Console.WriteLine(" 运行结果——{0}", result);           

            Console.ReadKey();
        }
        private static string TaskOper(string  name)
        {         

            Console.WriteLine("Task 线程 ID:{0} 上,是不是线程池中的线程:{1},名称: {2}",
            Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsThreadPoolThread, name);
            Thread.Sleep(2000);
            return string.Format("线程ID:{0},名称:{1}", Thread.CurrentThread.ManagedThreadId,name);
        }
        static Task<string> CreateTask(string name)
        {
            return new Task<string>(() => TaskOper(name));

        }
    }
}

然后大家运维了task1,使用start方法运维职务并等候结果。那一个任务会被放在线程池中运作,而且主线程会等待,直到义务完成并再次来到结果。

二.程序运维结果如下图。

Task二与task1相似,Task二通过RunSynchronously()方法运转的。这些任务运维在主线程中,那一个职责的输出与TaskOper方法输出结果一律。那就是task的优势,可以采用task对TaskOper方法举行优化,能够幸免使用线程池来实施1些进行时间尤其短的操作。

 图片 4

Task叁运维task一的格局,不过此次未有阻塞主线程,只是在职责成功在此以前循环打印出职分意况。

       
首先直接运营TaskOper方法,依照程序运转结果,大家能够知道那一个措施是被联合施行的。

       
然后大家运转了task1,使用start方法运行职责并等候结果。这一个任务会被放在线程池中运转,而且主线程会等待,直到任务完结并重回结果。

       
Task2与task壹相似,Task二通过RunSynchronously()方法运营的。那一个任务运转在主线程中,这些任务的出口与TaskOper方法输出结果同样。那就是task的优势,能够选用task对TaskOper方法进行优化,能够幸免使用线程池来推行一些执行时间非常短的操作。

       
Task3周转task一的格局,可是此番没有阻塞主线程,只是在职责到位从前循环打字与印刷出职责情形。