二十四线程编制程序学习笔记——职务并行库(一)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 接上文 多线程编程学习笔记——线程池(三)

     

     

      
前边大家学习了怎么着是线程,线程之间的一块儿,使用线程池。使用线程池能够削减我们大批量长时间操作的并行线程所用的操作系统财富。

      
后面大家上学了什么是线程,线程之间的联名,使用线程池。使用线程池能够减掉大家大批量短期操作的竞相线程所用的操作系统财富。

       在net framework
4.0中微软又提供了2个新的异步操作的功效,叫做任务并行库(TPL)。职务并行库的中坚是天职(task)。叁个职务代表了二个异步操作,譔操作能够透过多样方法运转,能够选拔或不应用独立的线程。

       在net framework
4.0中微软又提供了三个新的异步操作的意义,叫做职务并行库(TPL)。职务并行库的骨干是任务(task)。3个职务代表了1个异步操作,譔操作能够通过多样艺术运维,能够应用或不选择独立的线程。

       
一个职责(Task)能够因而多样格局和其它义务组合起来使用。例如,能够同时拉开五个职分,等待全体职责到位,再起三个职务展开操作。贰个任务能够有三个其余职分组成,那个职分也得以依次拥有本身的子任务。

       
二个职务(Task)能够由此二种方式和别的职分组合起来使用。例如,能够同时拉开四个职务,等待全部职务到位,再起三个职分展开操作。3个职责能够有多少个其余职分组成,这几个任务也得以依次拥有自身的子职务。

        
C#5.0及事后的本子都曾经停放了对TPL的援助,允许大家运用await与async关键字展开职责执行。

        
C#5.0及今后的版本都早就停放了对TPL的支撑,允许大家运用await与async关键字展开职务履行。

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

         以下示例,我们使用.Net
Framework 4.5随后版本。

 

 

一 、   创设义务

① 、   成立职分

       
下边包车型大巴以身作则,大家选拔task构造函数成立了三个职务。我们传入了一个lambda表明式做为操作职务。然后利用start运转职分。

       
上面包车型地铁演示,我们选拔task构造函数创建了五个职务。大家传入了一个lambda表明式做为操作职务。然后利用start运转职分。

       
接着,大家应用task.Run和task.startNew方法来运作多少个职分。与利用task构造函数差异之处,在于那四个被创设的职务会即时施行。所以不要显式地调用
这一个义务的Start方法。从task1到task4全部任务都以放在线程池中推行的,多次推行,能够窥见实施种种是不一致等的。

       
接着,我们利用task.Run和task.startNew方法来运作多个任务。与使用task构造函数分歧之处,在于那四个被创建的天职会应声施行。所以无需显式地调用
这个职责的Start方法。从task1到task4全体任务都以放在线程池中实践的,数次推行,能够窥见实施顺序是不同的。

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

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

  1. 代码如下:
  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); 

        }
    }
}

 

 

 2.运维结果如下图。作者把程序运转了两回。请自行查看分裂之处。

 2.运营结果如下图。我把程序运营了三遍。请自行查看差异之处。

图片 1

图片 2

 

 

② 、   使用职务执行基本的操作

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

        
本示例是从任务中收获结果值。我们透过差别的实践结果来映今后线程池中实践与在主线程中实行的区别之处。

        
本示例是从任务中获取结果值。大家通过分裂的实施结果来体现在线程池中实践与在主线程中实践的分歧之处。

 1. 代码如下:

 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<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));

        }
    }
}
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));

        }
    }
}

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

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

 图片 3

 图片 4

       
首先直接运营TaskOper方法,依照程序运转结果,我们可以清楚这些艺术是被一块施行的。

       
首先直接运营TaskOper方法,根据程序运转结果,大家得以知道这些主意是被联合执行的。

       
然后大家运行了task1,使用start方法运营任务并伺机结果。这么些任务会被放在线程池中运维,而且主线程会等待,直到职务达成并赶回结果。

       
然后大家运维了task1,使用start方法运营任务并等候结果。这些职务会被放在线程池中运作,而且主线程会等待,直到职务完成并重临结果。

       
Task2与task1相似,Task2通过RunSynchronously()方法运转的。这些职分运营在主线程中,那些职务的输出与TaskOper方法输出结果一律。那就是task的优势,能够接纳task对TaskOper方法实行优化,可以幸免使用线程池来施行一些推行时间相当长的操作。

       
Task2与task1相似,Task2通过RunSynchronously()方法运营的。那些职分运维在主线程中,这么些义务的输出与TaskOper方法输出结果同样。这便是task的优势,能够运用task对TaskOper方法进行优化,能够制止使用线程池来实施一些实践时间非常长的操作。

       
Task3运作task1的不二法门,不过这一次没有阻塞主线程,只是在任务到位以前循环打字与印刷出职分意况。

       
Task3周转task1的点子,不过此次没有阻塞主线程,只是在职务成功以前循环打字与印刷出职分处境。

相关文章