您的位置:68399皇家赌场 > 集群主机 > C#十2线程之基础篇1

C#十2线程之基础篇1

发布时间:2019-05-06 08:17编辑:集群主机浏览(137)

      为了模仿单核计算机,我们将ProcessorAffinity的值设置为1,现在那七个线程所迭代的次数将差距一点都非常大,并且程序的实践时间远远大于二秒。这是因为CPU的Computer时间超过二五%予以了高优先级的线程,而低优先级的线程获得格外少的CPU时间。

    多线程(基础篇二),四线程基础篇二

      在上一篇四线程(基础篇一)中,大家最首要讲述了哪些创立线程、中止线程、线程等待以及终止线程的有关文化,在本篇中大家承继讲述关于线程的有的文化。

    伍、鲜明线程的情事

       在那壹节中,大家将讲述怎样查看三个线程的场所,常常驾驭1个线程处于什么样意况是不行政管理用的。可是,要留心线程是单独运营的,它的气象恐怕随时变动。要翻开一个线程的景色,大家能够按如下步骤举行:

    一、使用Visual Studio 201伍开立多个新的调控台应用程序。

    2、双击张开“Program.cs”文件,然后修改为如下代码:

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 
     6 namespace Recipe05
     7 {
     8     class Program
     9     {
    10         static void DoNothing()
    11         {
    12             Sleep(TimeSpan.FromSeconds(2));
    13         }
    14 
    15         static void PrintNumbersWithStatus()
    16         {
    17             WriteLine("Starting...");
    18             WriteLine(CurrentThread.ThreadState.ToString());
    19 
    20             for(int i = 1; i < 10; i  )
    21             {
    22                 Sleep(TimeSpan.FromSeconds(2));
    23                 WriteLine(i);
    24             }
    25         }
    26 
    27         static void Main(string[] args)
    28         {
    29             WriteLine("Starting program...");
    30 
    31             Thread t1 = new Thread(PrintNumbersWithStatus);
    32             Thread t2 = new Thread(DoNothing);
    33 
    34             WriteLine(t1.ThreadState.ToString());
    35 
    36             t2.Start();
    37             t1.Start();
    38 
    39             for(int i = 1; i < 30; i  )
    40             {
    41                 WriteLine(i.ToString()   " - "   t1.ThreadState.ToString());
    42             }
    43 
    44             Sleep(TimeSpan.FromSeconds(6));
    45 
    46             t1.Abort();
    47 
    48             WriteLine("A thread has been aborted");
    49             WriteLine(t1.ThreadState.ToString());
    50             WriteLine(t2.ThreadState.ToString());
    51         }
    52     }
    53 }
    

    三、运转该调整台应用程序,运维效果(每回运转效果说不定区别)如下图所示:

    皇家赌场 1

      在上述代码中,大家在“Main”方法中定义了七个不等的线程t一和t二,t一线程在施行进度中被结束,t二线程成功实施完毕。我们得以利用Thread对象的ThreadState属性得到某些线程的事态消息,ThreadState属性是C#枚举类型。

      当程序试行到第壹四行代码处时,t1线程还未有实施,那一年t一线程的气象为“ThreadState.Unstarted”。

    皇家赌场,  当程序推行到第一7行代码处时,t一线程开首选行,那个时候该线程的景况为“ThreadState.Running”。

      当运转到第一九~4贰行代码处时,主线程开头施行循环语句,持续打字与印刷出2九条t壹线程的地方,因为在“PrintNumbersWithStatus”方法中调用了“Thread.Sleep”方法,因而在实践主线程的巡回的进度中,t1线程的景观在“ThreadState.Running”和“ThreadState.WaitSleepJoin”之间转移。

      当程序试行到第陆4行代码处时,在主线程中调用了“Thread.Sleep”方法,在伺机六秒之内,“PrintNumbersWithStatus”方法中的for循环代码不断实践,由此打字与印刷出1、2、三共三行数字。

      当程序实践到第五六行代码处时,大家调用了t一的“Abort”方法,从而t壹线程被终止。

      当程序奉行到第六玖行代码处时,由于已经在t一线程上调用了“Abort”方法,由此,它的情形为“ThreadState.Aborted”或“ThreadState.AbortRequested”。

      当程序实行到第40行代码处时,因为t二线程平常试行完成,由此t二线程的情况为“ThreadState.Stopped”。

    6、线程优先级

       在这一小节中,我们将讲述线程的优先级,线程的优先级鲜明了线程所能使用CPU时间的轻重缓急。大家按以下步骤来产生线程优先级的就学:

    壹、使用Visual Studio 20一伍创立1个新的调节台应用程序。

    二、双击展开“Program.cs”文件,修改代码如下所示:

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 using static System.Diagnostics.Process;
     6 
     7 namespace Recipe06
     8 {
     9     class ThreadSample
    10     {
    11         private bool isStopped = false;
    12 
    13         public void Stop()
    14         {
    15             isStopped = true;
    16         }
    17 
    18         public void CountNumbers()
    19         {
    20             long counter = 0;
    21             while (!isStopped)
    22             {
    23                 counter  ;
    24             }
    25 
    26             WriteLine($"{CurrentThread.Name} with {CurrentThread.Priority,10} priority has a count = {counter,15:N0}");
    27         }
    28     }
    29 
    30     class Program
    31     {
    32         static void RunThreads()
    33         {
    34             var sample = new ThreadSample();
    35 
    36             var threadOne = new Thread(sample.CountNumbers);
    37             threadOne.Name = "ThreadOne";
    38 
    39             var threadTwo = new Thread(sample.CountNumbers);
    40             threadTwo.Name = "ThreadTwo";
    41 
    42             threadOne.Priority = ThreadPriority.Highest;
    43             threadTwo.Priority = ThreadPriority.Lowest;
    44 
    45             threadOne.Start();
    46             threadTwo.Start();
    47 
    48             Sleep(TimeSpan.FromSeconds(2));
    49             sample.Stop();
    50         }
    51 
    52         static void Main(string[] args)
    53         {
    54             WriteLine($"Current thread priority: {CurrentThread.Priority}");
    55             WriteLine("Running on all cores available");
    56 
    57             RunThreads();
    58 
    59             Sleep(TimeSpan.FromSeconds(2));
    60 
    61             WriteLine("Running on a single core");
    62             GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
    63             RunThreads();
    64         }
    65     }
    66 }
    

    三、运行该调控台应用程序,运转效果(每一遍运行作效果果兴许两样)如下图所示:

    皇家赌场 2

      在上述代码中,大家定义了多个例外的线程threadOne和threadTwo。threadOne线程具备最高的优先级“ThreadPriority.Highest”,threadTwo具备最低的优先级“ThreadPriority.Lowest”。

      在程序实行到第肆七行代码处,若是我们的Computer是多核处理器,我们就要二秒内获得开首结果,并且有所最高优先级的threadOne线程要比有所最低优先级的threadTwo线程的迭代次数越来越多一些,但也不会相差太远。然则,要是大家的管理器是单核Computer,则结果大分裂样。

      为了模仿单核Computer,我们将ProcessorAffinity的值设置为一,现在那三个线程所迭代的次数将差异非常的大,并且程序的实行时间远远不唯有二秒。那是因为CPU的管理器时间超过四分之2授予了高优先级的线程,而低优先级的线程获得十分少的CPU时间。

    7、前台线程和后台线程

      在这一小节中,大家将讲述什么是前台线程和后台线程,并且讲述怎么着设置那个选项以震慑程序的行事。我们按以下步骤来完成前台线程和后台线程的读书:

    1、使用Visual Studio 201五开立三个新的调节台应用程序。

    二、双击张开“Program.cs”文件,修改代码如下所示:

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 
     6 namespace Recipe07
     7 {
     8     class ThreadSample
     9     {
    10         private readonly int iterations;
    11 
    12         public ThreadSample(int iterations)
    13         {
    14             this.iterations = iterations;
    15         }
    16 
    17         public void CountNumbers()
    18         {
    19             for(int i = 0; i < iterations; i  )
    20             {
    21                 Sleep(TimeSpan.FromSeconds(0.5));
    22                 WriteLine($"{CurrentThread.Name} prints {i}");
    23             }
    24         }
    25     }
    26 
    27     class Program
    28     {
    29         static void Main(string[] args)
    30         {
    31             var sampleForeground = new ThreadSample(10);
    32             var sampleBackground = new ThreadSample(20);
    33 
    34             var threadOne = new Thread(sampleForeground.CountNumbers);
    35             threadOne.Name = "ForegroundThread";
    36 
    37             var threadTwo = new Thread(sampleBackground.CountNumbers);
    38             threadTwo.Name = "BackgroundThread";
    39             threadTwo.IsBackground = true;
    40 
    41             threadOne.Start();
    42             threadTwo.Start();
    43         }
    44     }
    45 }
    

    三、运维该调节台应用程序,运转效果(每一次运维作效果果兴许两样)如下图所示:

    皇家赌场 3

      在上述代码中,大家定义了五个不一致的线程threadOne和threadTwo。当咱们创造3个线程时,该线程展现地是三个前台线程,比方threadOne。若是大家要将三个线程设置为后台线程,只须求将该线程的“IsBackground”属性设置为“true”就能够,举例threadTwo。大家还配备了四个线程实践的循环次数不平等,threadOne线程所实践的巡回次数为10遍,threadTwo线程所试行的巡回次数为20回,由此threadOne线程要比threadTwo线程早实行完成。

      从推行结果上来看,当threadOne线程实践达成后,主程序也终结了,并且后台线程也被甘休了,那正是前台线程和后台线程的不一样:进度会等待全部的前台进度实施实现后才截止,单不会等待后台进度施行达成。

    8、向线程传递参数

       在这一小节,作者将讲述如何向3个线程传递参数,大家将应用不一致的主意来造成这几个专业,具体步骤如下所示:

    1、使用Visual Studio 20一伍创建三个新的调控台应用程序。

    二、双击展开“Program.cs”文件,修改代码如下所示:

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 
     6 namespace Recipe08
     7 {
     8     class ThreadSample
     9     {
    10         private readonly int iterations;
    11 
    12         public ThreadSample(int iterations)
    13         {
    14             this.iterations = iterations;
    15         }
    16 
    17         public void CountNumbers()
    18         {
    19             for(int i = 1; i <= iterations; i  )
    20             {
    21                 Sleep(TimeSpan.FromSeconds(0.5));
    22                 WriteLine($"{CurrentThread.Name} prints {i}");
    23             }
    24         }
    25     }
    26 
    27     class Program
    28     {
    29         static void Count(object iterations)
    30         {
    31             CountNumbers((int)iterations);
    32         }
    33 
    34         static void CountNumbers(int iterations)
    35         {
    36             for(int i = 1; i <= iterations; i  )
    37             {
    38                 Sleep(TimeSpan.FromSeconds(0.5));
    39                 WriteLine($"{CurrentThread.Name} prints {i}");
    40             }
    41         }
    42 
    43         static void PrintNumber(int number)
    44         {
    45             WriteLine(number);
    46         }
    47 
    48         static void Main(string[] args)
    49         {
    50             var sample = new ThreadSample(10);
    51 
    52             var threadOne = new Thread(sample.CountNumbers);
    53             threadOne.Name = "ThreadOne";
    54             threadOne.Start();
    55             threadOne.Join();
    56 
    57             WriteLine("--------------------------");
    58 
    59             var threadTwo = new Thread(Count);
    60             threadTwo.Name = "ThreadTwo";
    61             threadTwo.Start(8);
    62             threadTwo.Join();
    63 
    64             WriteLine("--------------------------");
    65 
    66             var threadThree = new Thread(() => CountNumbers(12));
    67             threadThree.Name = "ThreadThree";
    68             threadThree.Start();
    69             threadThree.Join();
    70 
    71             WriteLine("--------------------------");
    72 
    73             int i = 10;
    74             var threadFour = new Thread(() => PrintNumber(i));
    75 
    76             i = 20;
    77             var threadFive = new Thread(() => PrintNumber(i));
    78 
    79             threadFour.Start();
    80             threadFive.Start();
    81         }
    82     }
    83 }
    

    三、运维该调节台应用程序,运转效果如下图所示:

    皇家赌场 4

      在第50~5伍行代码处,我们率先创建了二个Thread萨姆ple类型的靶子,并将数字10传递给了该类型的构造方法。然后我们将Thread萨姆ple对象的“CountNumbers”方法传递给了线程threadOne的构造方法,“CountNumbers”方法将要线程threadOne中被实施,因而大家透过“CountNumbers”方法将数字10传递给了线程threadOne。

      在第59~6二行代码处,我们应用“Thread.Start”的重载方法将三个对象传递给线程threadTwo,要使该段代码不易运维,大家要力保在布局threadTwo线程时,传给给Thread的构造方法的委托要包括2个object类型的参数。在那段代码中,大家将8看作三个指标传递给“Count”方法,该措施有调用了同名的重载方法将object对象变换为整数门类。

      在第66~6九行代码处,大家在开立threadThree线程时,给Thread构造方法传递的是三个lambda说明式,该表明式定义了1个不属于其余类的办法,我们在该lambda表明式中调用了“CountNumbers”方法,并将1二传递给了“CountNumbers”方法,通过lambda表明式,大家将1二传递给了threadThree线程。

      注意:当大家将1个局地变量用于四个lambda表达式时,那个lambda表明式将会共享那些变量的值,在第10三~80行代码处,大家将部分变量用于了多个lambda表明式,我们运维threadFour和threadFive线程后,大家发掘打字与印刷出来的结果都以20。

       未完待续!

    在上1篇三四线程(基础篇1)中,大家主要讲述了怎么样创设线程、中止线程、线程等待以及终止线程的相...

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 
     5 namespace Recipe01
     6 {
     7     class Program
     8     {
     9         static void PrintNumbers()
    10         {
    11             WriteLine("Starting...");
    12             for (int i = 1; i < 10; i  )
    13             {
    14                 WriteLine(i);
    15             }
    16         }
    17 
    18         static void Main(string[] args)
    19         {
    20             Thread t = new Thread(PrintNumbers);
    21             t.Start();
    22             PrintNumbers();
    23         }
    24     }
    25 }
    

      在第50~55行代码处,我们先是成立了三个Thread萨姆ple类型的目的,并将数字10传递给了该品种的构造方法。然后大家将Thread萨姆ple对象的“CountNumbers”方法传递给了线程threadOne的构造方法,“CountNumbers”方法将要线程threadOne中被实践,由此我们由此“CountNumbers”方法将数字10传递给了线程threadOne。

    二、双击展开“Program.cs”文件,编写代码如下所示:

      在第66~6九行代码处,大家在创设threadThree线程时,给Thread构造方法传递的是三个lambda表明式,该表达式定义了1个不属于其余类的法子,我们在该lambda表达式中调用了“CountNumbers”方法,并将1二传递给了“CountNumbers”方法,通过lambda表明式,我们将1二传递给了threadThree线程。

    一、使用Visual Studio 20一伍创立八个新的调控台应用程序。

    三、运转该调整台应用程序,运维效果(每趟运维效果大概分化)如下图所示:

    2、双击张开“Program.cs”文件,编写如下代码:

    三、运营该调节台应用程序,运营作效果果(每回运营效果兴许两样)如下图所示:

      在第二1行代码处,大家运营线程。

    2、双击展开“Program.cs”文件,修改代码如下所示:

    • 始建线程
    • 暂停线程
    • 线程等待
    • 结束线程
    • 明确线程的气象
    • 线程优先级
    • 前台线程和后台线程
    • 向线程传递参数
    • 使用C#的lock关键字锁定线程
    • 行使Monitor锁定线程
    • 管理相当

      注意:当我们将3个部分变量用于多少个lambda表明式时,那一个lambda表明式将会共享这几个变量的值,在第8三~80行代码处,大家将一部分变量用于了多少个lambda表明式,我们运转threadFour和threadFive线程后,大家开掘打字与印刷出来的结果都以20。

    二、确认保证该调整台程序使用.NET Framework 肆.6或以上版本。然则在该篇中的全数示例使用很低版本能够平常办事。

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 
     6 namespace Recipe07
     7 {
     8     class ThreadSample
     9     {
    10         private readonly int iterations;
    11 
    12         public ThreadSample(int iterations)
    13         {
    14             this.iterations = iterations;
    15         }
    16 
    17         public void CountNumbers()
    18         {
    19             for(int i = 0; i < iterations; i  )
    20             {
    21                 Sleep(TimeSpan.FromSeconds(0.5));
    22                 WriteLine($"{CurrentThread.Name} prints {i}");
    23             }
    24         }
    25     }
    26 
    27     class Program
    28     {
    29         static void Main(string[] args)
    30         {
    31             var sampleForeground = new ThreadSample(10);
    32             var sampleBackground = new ThreadSample(20);
    33 
    34             var threadOne = new Thread(sampleForeground.CountNumbers);
    35             threadOne.Name = "ForegroundThread";
    36 
    37             var threadTwo = new Thread(sampleBackground.CountNumbers);
    38             threadTwo.Name = "BackgroundThread";
    39             threadTwo.IsBackground = true;
    40 
    41             threadOne.Start();
    42             threadTwo.Start();
    43         }
    44     }
    45 }
    

    叁、线程等待

      当程序执行到第二肆行代码处时,t一线程还向来不试行,那一年t一线程的事态为“ThreadState.Unstarted”。

      在第二行代码处,我们应用了C# 六.0的using static性子,使用了该特性之后,在代码中允许我们在采纳System.Console类型的静态方法的时候不供给钦赐其体系名。

      在程序施行到第肆7行代码处,纵然大家的微管理器是多核管理器,我们就要贰秒内获取开始结果,并且存有最高优先级的threadOne线程要比全数最低优先级的threadTwo线程的迭代次数越多一些,但也不会距离太远。可是,要是大家的微型Computer是单核Computer,则结果大不一致。

    4、运维该调节台应用程序,运营效果(每一遍运维效果兴许不一样)如下图所示:

    一、使用Visual Studio 二零一四创制三个新的调节台应用程序。

    皇家赌场 5

      在上述代码中,我们在“Main”方法中定义了三个不一样的线程t一和t2,t1线程在施行进度中被终止,t贰线程成功施行完成。大家能够利用Thread对象的ThreadState属性得到有个别线程的气象音讯,ThreadState属性是C#枚举类型。

    1、使用Visual Studio 201五开立二个新的调节台应用程序。

    2、双击展开“Program.cs”文件,修改代码如下所示:

     1 using System;
     2 using System.Threading;
     3 using static System.Console;
     4 using static System.Threading.Thread;
     5 
     6 namespace Recipe04
     7 {
     8     class Program
     9     {
    10         static void PrintNumbers()
    11         {
    12             WriteLine("Starting...");
    13 
    14             for (int i = 1; i < 10; i  )
    15             {
    16                 WriteLine(i);
    17             }
    18         }
    19 
    20         static void PrintNumbersWithDelay()
    21         {
    22             WriteLine("Starting...");
    23             for (int i = 1; i < 10; i  )
    24             {
    25                 Sleep(TimeSpan.FromSeconds(2));
    26                 WriteLine(i);
    27             }
    28         }
    29 
    30         static void Main(string[] args)
    31         {
    32             WriteLine("Starting program...");
    33             Thread t = new Thread(PrintNumbersWithDelay);
    34             t.Start();
    35             Thread.Sleep(TimeSpan.FromSeconds(6));
    36             t.Abort();
    37             WriteLine("A thread has been aborted");
    38             t = new Thread(PrintNumbers);
    39             t.Start();
    40             PrintNumbers();
    41         }
    42     }
    43 }
    

    7、前台线程和后台线程

      在那一节中,大家将讲述怎样终止另三个线程的实行。步骤如下:

    1、使用Visual Studio 2015创立贰个新的调控台应用程序。

      在第3陆行代码处,我们在“Main”方法中调用调用“t.Join”方法,该方法允许我们等待线程t实践完结后,再推行“Main”方法中剩下的代码。有了该本领,我们得以协同多少个线程的实行步骤。第二个线程等待第2个线程施行达成后,再开展其余的办事,在首先个线程等待时期,第三个线程的意况为“bolcked”状态,和大家调用Thread.Sleep的意况一样。

    二、双击展开“Program.cs”文件,修改代码如下所示:

      在第20~2九行代码处,大家定义了二个新的方法“PrintNumbersWithDelay”,该措施将在大家新建的线程中运转。须要专注的是在第3六行代码处,大家选用了“Thread”类的静态方法“Sleep”,该方法使得每一趟循环都会等待贰分钟施行。

    本文由68399皇家赌场发布于集群主机,转载请注明出处:C#十2线程之基础篇1

    关键词: 68399皇家赌场 C# Multithreadi 多线程

上一篇:iOS didReceiveMemoryWarning 的管理

下一篇:没有了