一起谈.NET技术，关于C#线程，线程池和并行运算的简单使用和对比

前言：看了书上两个使用C#4.0并行编程的demo，又对照以前收藏的网上几篇讲述线程池的雄文，一并整理，写个示例总结一下。写这篇文章的时候，发现关于线程的好几个基础的重要的知识点自己都不熟悉，而且可能习惯性认知浅薄，所以痛苦的无以复加，不知道到底要说什么。不想看文章的可以直接下载最后的示例，本文代码主要参考Marc Clifton的“.NET's ThreadPool Class - Behind The Scenes”，对新手也许有帮助。

　　参考：

　　http://msdn.microsoft.com/zh-cn/library/system.threading.threadpool(VS.80).aspx

　　http://www.codeproject.com/KB/threads/threadtests.aspx

　　http://www.codeproject.com/KB/threads/smartthreadpool.aspx

　　http://blog.zhaojie.me/2009/07/thread-pool-1-the-goal-and-the-clr-thread-pool.html  （老赵的浅谈线程池上中下三篇）

　　先大概看一下控制台应用程序的Main方法的主要代码：



static bool done = false;
static decimal count2 = 0;
static int threadDone = 0;//标志启用线程数?
        static System.Timers.Timer timer = new System.Timers.Timer(1000);


static decimal[] threadPoolCounters = new decimal[10];
static Thread[] threads = new Thread[10];
static System.Timers.Timer[] threadTimers = new System.Timers.Timer[10];


static void Main(string[] args)
        {
            timer.Stop();
/*当 AutoReset 设置为 false 时，Timer 只在第一个 Interval 过后引发一次 Elapsed 事件。
             若要保持以 Interval 时间间隔引发 Elapsed 事件，请将 AutoReset 设置为 true。*/
            timer.AutoReset = false;
            timer.Elapsed += new ElapsedEventHandler(OnTimerEvent);//当timer.Start()时，触发事件
            decimal total = 0;


// raw test
            decimal count1 = SingleThreadTest();//单一线程，一跑到底
            Console.WriteLine("Single thread count = " + count1.ToString());


// create one thread, increment counter, destroy thread, repeat
            Console.WriteLine();
            CreateAndDestroyTest();//创建一个线程，运算，然后销毁该线程 重复前面的动作
            Console.WriteLine("Create and destroy per count = " + count2.ToString());


// Create 10 threads and run them simultaneously
//一次性创建10个线程，然后遍历使线程执行运算
            Console.WriteLine();
            InitThreadPoolCounters();
            InitThreads();
            StartThreads();
while (threadDone != 10) { };
            Console.WriteLine("10 simultaneous threads:");
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());
            Console.WriteLine();


Console.WriteLine("///////////////////////////////////////////////////");


// using ThreadPool
//直接通过线程池的QueueUserWorkItem方法，按队列执行10个任务
            Console.WriteLine();
            Console.WriteLine("ThreadPool:");
            InitThreadPoolCounters();
            QueueThreadPoolThreads();
while (threadDone != 10) { };
            Console.WriteLine("ThreadPool: 10 simultaneous threads:");
            total = 0;
for (int i = 0; i < 10; i++)
            {
//                threadTimers[i].Stop();
//                threadTimers[i].Dispose();
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());


// using SmartThreadPool
//通过Amir Bar的SmartThreadPool线程池，利用QueueUserWorkItem方法，按队列执行10个任务
            Console.WriteLine();
            Console.WriteLine("SmartThreadPool:");
            InitThreadPoolCounters();
            QueueSmartThreadPoolThreads();
while (threadDone != 10) { };
            Console.WriteLine("SmartThreadPool: 10 simultaneous threads:");
            total = 0;
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());


// using ManagedThreadPool
//通过Stephen Toub改进后的线程池，利用QueueUserWorkItem方法，按队列执行10个任务
            Console.WriteLine();
            Console.WriteLine("ManagedThreadPool:");
            InitThreadPoolCounters();
            QueueManagedThreadPoolThreads();
while (threadDone != 10) { };
            Console.WriteLine("ManagedThreadPool: 10 simultaneous threads:");
            total = 0;
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());


// using C#4.0 Parallel
//通过Tasks.Parallel.For进行并行运算
            Console.WriteLine();
            Console.WriteLine("Parallel:");
            InitThreadPoolCounters();
            UseParallelTasks();
while (threadDone != 10) { };
            Console.WriteLine("Parallel: 10 simultaneous threads:");
            total = 0;
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());
        }


　　我们可以先熟悉一下大致思路。代码中，我们主要依靠输出的数字count或者total来判断哪个方法执行效率更高（原文是How Hign Can I Count?），通常输出的数字越大，我们就认为它”干的活越多“，效率越高。主要实现过程就是通过一个静态的System.Timers.Timer对象的timer实例，设置它的Interval属性和ElapsedEventHandler事件：




static System.Timers.Timer timer = new System.Timers.Timer(1000);
/*当 AutoReset 设置为 false 时，Timer 只在第一个 Interval 过后引发一次 Elapsed 事件。
若要保持以 Interval 时间间隔引发 Elapsed 事件，请将 AutoReset 设置为 true。*/
timer.AutoReset = false;
timer.Elapsed += new ElapsedEventHandler(OnTimerEvent);//当timer.Start()时，触发事件


　　其中，timer的事件触发的函数：




static void OnTimerEvent(object src, ElapsedEventArgs e)
{
　　done = true;
}


　　每次timer.Start执行的时候，一次测试就将开始，这样可以确保测试的不同方法都在1000毫秒内跑完。


　　下面开始具体介绍几个方法：


　　A、线程


　　这个非常简单，就是通过主线程计算在1000毫秒内，count从0递增加到了多少：




/// <summary>
/// 单一线程，一跑到底
/// </summary>
/// <returns></returns>
        static decimal SingleThreadTest()
        {
            done = false;
decimal counter = 0;
            timer.Start();
while (!done)
            {
++counter;
            }
return counter;
        }


　　while判断可以保证方法在1000毫秒内执行完成。


　　B、多线程


　　这个多线程方法比较折腾，先创建线程，然后运行，最后销毁线程，这就是一个线程执行单元，重复10次这个线程执行单元。




/// <summary>
/// 创建一个线程，运算，然后销毁该线程 重复前面的动作
/// </summary>
      static void CreateAndDestroyTest()
      {
          done = false;
          timer.Start();
while (!done)
          {
              Thread counterThread = new Thread(new ThreadStart(Count1Thread));
              counterThread.IsBackground = true;//后台线程
              counterThread.Start();
while (counterThread.IsAlive) { };
          }
      }


　　那个ThreadStart委托对应的方法Count1Thread如下：




static void Count1Thread()
        {
++count2; //静态字段count2自增
        }


　　从表面上看，大家估计都可以猜到，效果可能不佳。


　　C、还是多线程


　　这个方法不判断线程的执行状态，不用等到一个线程销毁后再创建一个线程，然后执行线程方法。线程执行的方法就是根据线程的Name找到一个指定数组的某一索引，并累加改变数组的值：




static void InitThreadPoolCounters()
        {
            threadDone = 0;
for (int i = 0; i < 10; i++)
            {
                threadPoolCounters[i] = 0;
            }
        }


/// <summary>
/// 初始化10个线程
/// </summary>
        static void InitThreads()
        {
for (int i = 0; i < 10; i++)
            {
                threads[i] = new Thread(new ThreadStart(Count2Thread));
                threads[i].IsBackground = true;
                threads[i].Name = i.ToString();//将当前线程的Name赋值为数组索引，在Count2Thread方法中获取对应数组
            }
        }


/// <summary>
/// 开始多线程运算
/// </summary>
        static void StartThreads()
        {
            done = false;
            timer.Start();
for (int i = 0; i < 10; i++)
            {
                threads[i].Start();
            }
        }


　　其中，每一个线程需要执行的委托方法：




static void Count2Thread()
        {
int n = Convert.ToInt32(Thread.CurrentThread.Name);//取数组索引
            while (!done)
            {
++threadPoolCounters[n];
            }
            Interlocked.Increment(ref threadDone);//以原子操作的形式保证threadDone递增
        }


　　在测试过程中，我们看代码：




// Create 10 threads and run them simultaneously
//一次性创建10个线程，然后遍历使线程执行运算
            Console.WriteLine();
            InitThreadPoolCounters();
            InitThreads();
            StartThreads();
while (threadDone != 10) { };
            Console.WriteLine("10 simultaneous threads:");
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("T" + i.ToString() + " = " + threadPoolCounters[i].ToString() + "   ");
                total += threadPoolCounters[i];
            }
            Console.WriteLine("Total = " + total.ToString());
            Console.WriteLine();


　　最后算出这个数组的所有元素的总和，就是这10个线程在1000毫秒内所做的事情。其中， while (threadDone != 10) { };这个判断非常重要。这个方法看上去没心没肺，线程创建好就不管它的死活了（还是管活不管死？），所以效率应该不低。


　　实际上，我在本地测试并看了一下输出，表面看来，按count大小逆序排列：C>A>B，这就说明多线程并不一定比单线程运行效率高。其实B之所以效率不佳，主要是由于这个方法大部分的”精力“花在线程的执行状态和销毁处理上。


　　注意，其实C和A、B都没有可比性，因为C计算的是数组的总和，而A和B只是简单的对一个数字进行自加。


　　ps：C这一块说的没有中心，想到哪写到哪，所以看起来写得很乱，如果看到这里您还觉着不知所云，建议先下载最后的demo，先看代码，再对照这篇文章。


　　好了，到这里，我们对线程的创建和使用应该有了初步的了解。细心的人可能会发现，我们new一个Thread，然后给线程实例设置属性，比如是否后台线程等等，其实这部分工作可以交给下面介绍的线程池ThreadPool来做（D、E和F主要介绍线程池）。


　　D、线程池ThreadPool


　　在实际的项目中大家可能使用最多最熟悉的就是这个类了，所以没什么可说的：




/// <summary>
/// ThreadPool测试
/// </summary>
        static void QueueThreadPoolThreads()
        {
            done = false;
for (int i = 0; i < 10; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(Count3Thread), i);
            }


timer.Start();
        }


static void Count3Thread(object state)
        {
int n = (int)state;
while (!done)
            {
++threadPoolCounters[n];
            }
            Interlocked.Increment(ref threadDone);
        }


　　我们知道线程池里的线程默认都是后台线程，所以它实际上简化了线程的属性设置，更方便异步编程。


　　需要说明的是，线程池使用过程中会有这样那样的缺陷（虽然本文的几个线程池任务都不会受这种缺陷影响）。比如，我们一次性向线程池中加入100个任务，但是当前的系统可能只支持25个线程，并且每个线程正处于”忙碌“状态，如果一次性加入池中系统会处理不过来，那么多余的任务必须等待，这就造成等待的时间过长，系统无法响应。还好，ThreadPool提供了GetAvailableThreads方法，可以让你知道当前可用的工作线程数量。




static void QueueThreadPoolThreads()
        {
            done = false;
for (int i = 0; i < 10; i++)
            {
//ThreadPool.QueueUserWorkItem(new WaitCallback(Count3Thread), i); //直接给程序池添加任务有时是很草率的


WaitCallback wcb = new WaitCallback(Count3Thread);
int workerThreads, availabeThreads;
                ThreadPool.GetAvailableThreads(out workerThreads, out availabeThreads);
if (workerThreads > 0)//可用线程数>0
                {
                    ThreadPool.QueueUserWorkItem(wcb, i);
                }
else
                {
//to do 可以采取一种策略，让这个任务合理地分配给线程
                }
            }


　　如果没有可用的工作线程数，必须设计一定的策略，让这个任务合理地分配给线程。


　　也许就是类似于上面那样的限制，很多开发者都自己创建自己的线程池，同时也就有了后面的SmartThreadPool和ManagedThreadPool大展身手的机会。


　　E、线程池SmartThreadPool


　　大名鼎鼎的SmartThreadPool，但是我从来没在项目中使用过，所以只是找了一段简单的代码测试一下：




/// <summary>
/// SmartThreadPool测试
/// </summary>
        static void QueueSmartThreadPoolThreads()
        {
            SmartThreadPool smartThreadPool = new SmartThreadPool();
// Create a work items group that processes 
// one work item at a time
            IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(1);


done = false;
            timer.Start();
for (int i = 0; i < 10; i++)
            {
                wig.QueueWorkItem(new WorkItemCallback(Count4Thread), i);
            }
// Wait for the completion of all work items in the work items group
            wig.WaitForIdle();
            smartThreadPool.Shutdown();
        }


static object Count4Thread(object state)
        {
int n = (int)state;
while (!done)
            {
++threadPoolCounters[n];
            }
            Interlocked.Increment(ref threadDone);
return null;
        }


　　自从收藏这个SmartThreadPool.dll后，我还从没有在项目中使用过。查看它的源码注释挺少也挺乱的，不知道有没有高人知道它的一个效率更好的方法。您也可以看看英文原文，自己尝试体验一下。如果您熟悉使用SmartThreadPool，欢迎讨论。


　　F、线程池ManagedThreadPool


　　Stephen Toub这个完全用C#托管代码实现的线程池也非常有名，在Marc Clifton的英文原文中，作者也不吝溢美之词，赞它“quite excellent”，用当前异军突起的一个词汇形容就是太给力了，于我心有戚戚焉：




/// <summary>
/// ManagedThreadPool测试
/// </summary>
        static void QueueManagedThreadPoolThreads()
        {
            done = false;
            timer.Start();
for (int i = 0; i < 10; i++)
            {
                Toub.Threading.ManagedThreadPool.QueueUserWorkItem(new WaitCallback(Count5Thread), i);
            }
        }
static void Count5Thread(object state)
        {
int n = (int)state;
while (!done)
            {
++threadPoolCounters[n];
            }
            Interlocked.Increment(ref threadDone);
        }


　　对于这个托管的线程池，我个人的理解，就是它在管理线程的时候，这个池里还有一个缓存线程的池，即一个ArrayList对象。它一开始就初始化了一定数量的线程，并通过ProcessQueuedItems方法保证异步执行进入池中的队列任务（那个死循环有时可能导致CPU过分忙碌），这样在分配异步任务的时候，就省去了频繁去创建（new）一个线程。同时它在实现信号量（Semaphore）的同步和线程出入队列的设计上都可圈可点，非常巧妙，强烈推荐您阅读它的源码。


　　G、并行运算


　　下面的示例，我只使用了简单的System.Threading.Tasks.Parallel.For 对应的for 循环的并行运算：




/// <summary>
/// 并行运算测试
/// </summary>
        static void UseParallelTasks()
        {
            done = false;
            timer.Start();
// System.Threading.Tasks.Parallel.For - for 循环的并行运算
            System.Threading.Tasks.Parallel.For(0, 10, (i) => { Count6Thread(i); });
        }
static void Count6Thread(object state)
        {
int n = (int)state;
while (!done)
            {
++threadPoolCounters[n];
            }
            Interlocked.Increment(ref threadDone);
        }


　　没有什么要特殊说明的，就是新类库的使用。看代码，好像比使用线程或线程池更加简单直接，有机会争取多用一用。我在本地测试的时候，在Release版本下，按照count的大小逆序排列，总体上G>D>F>E。需要注意到一件事，就是SmartThreadPool中排入队列的任务是一个返回值为Object的委托类型，这和其他的几个没有返回的（void类型）不同。SmartThreadPool口碑还是不错的，也许是我没有正确使用它。


　　最后小结一下：本文主要列举了C#中我所知道的几种常见的异步处理的方法，欢迎大家纠错或补充。


　　示例下载：demo
				


				
时间： 2024-09-19 23:33:04

		
		


		


	

	
	

		


		
一起谈.NET技术，关于C#线程，线程池和并行运算的简单使用和对比的相关文章


								

		

			

                关于C#线程，线程池和并行运算的简单使用和对比
			

		

		

									

				前言:看了书上两个使用C#4.0并行编程的demo,又对照以前收藏的网上几篇讲述线程池的雄文,一并整理,写个示例总结一下.写这篇文章的时候,发现关于线程的好几个基础的重要的知识点自己都不熟悉,而且可能习惯性认知浅薄,所以痛苦的无以复加,不知道到底要说什么.不想看文章的可以直接下载最后的示例,本文代码主要参考Marc Clifton的".NET's ThreadPool Class - Behind The Scenes",对新手也许有帮助. 参考: http://msdn.micros			

		

	

				

		

			

                一起谈.NET技术，使用WCF实现SOA面向服务编程——简单的WCF开发实例
			

		

		

									

				前面为大家介绍过WCF的特点,现在再讲解一下WCF基础概念. 在WCF里,各个Application之间的通信是由EndPoint来实现的,EndPoint是WCF实现通信的核心要素.一个WCF Service可由多个EndPoint集合组成,每个EndPoint只能有一种绑定,就是说EndPoint就是通信的入口,客户端和服务端通过 EndPoint交换信息. <service name = " " >< endpoint address = ""			

		

	

				

		

			

                一起谈.NET技术，Visual Studio DSL 入门 3---创建一个简单的DSL模型
			

		

		

									

				     从这节开始我们就开始我们的DSL之旅, 首先确保你已经安装了Visual Studio Sdk,并且使用的是Visual Studio 2008.我们先大概创建一个简单的DSL项目,通过这个项目来了解dsl的开发环境和流程. 1. 打开VS.NET ,新建--项目, 点击其它项目类型--扩展性(Extensibility). 这里列出来了vs.net扩展类型的项目,包括Addin,VSPackage,Dsl等项目类型,选择"Domain Specific Lan  guage Desi			

		

	

				

		

			

                一起谈.NET技术，一步一步教你实现简单的自定义错误跟踪
			

		

		

									

				一.设计xml,应该包含下面信息: 1.Datetime:  发生错误/异常的日期和时间2.File name: 发生错误/异常的文件名3.Class name : 发生错误/异常的类名4.Methodname: 发生错误/异常的方法名5.Errormethod :  包含错误代码的函数名字6.Message :错误/异常的信息7.Error details: 错误/异常详情8.IP : 客户端IP地址9.URL : 发生错误的URL DemoXML: DemoXML xml version=			

		

	

				

		

			

                线程池的介绍及简单实现
			

		

		

									

				服务器程序利用线程技术响应客户请求已经司空见惯,可能您认为这样做效率已经很高,但您有没有想过优化一下使用线程的方法.该文章将向您介绍服务器程序如何利用线程池来优化性能并提供一个简单的线程池实现. 线程池的技术背景 在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源.在Java中更是如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收.所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些很耗资源的对象创建和销毁.如何利			

		

	

				

		

			

                一起谈.NET技术，WebForm：毒药还是利器？
			

		

		

									

				一.Webform的诞生及运行机制,web开发带来的革命性变化 九十年代中期,Internet崭露头角.为了进军Web应用程序行业,微软开发了Active ServerPages(ASP).ASP是开发Web页面的一种快速.简便的方式.ASP页面由一个页面组成,其中包含了标记和语言的混合.ASP的强大之处在于,在页面发送给终端用户的Web浏览器之前,可以在页面上包含在Web服务器上执行的VBScript或JScript代码指令.这是创建动态Web页面的一种简单方式,动态Web页面可以根据开发人员			

		

	

				

		

			

                一起谈.NET技术，.Net下的分布式缓存(2)--实现分布式缓存同步的手段
			

		

		

									

				前不久,俺写了篇文章谈到了.Net下面的分布式缓存的一些问题,并结合DNT里面实现模式发表了一些自己的看法,近来通过学习相关的东西又有了一些新的体会, 写在这里作为分布式缓存列系文章的第二部分. 其实对于性的扩展无非是Scale Up(向上扩展)或者是Scale Out(向外扩展), 微软对此的看法是一个App的缓存最好是以它自己为物理边界进行读写,而不要放到别处去,这样带的问题可能有对象的序列化传送,反序列化,网络连接开销,跨进程的开销,对于高性能的站点来说都是不能忽视的问题.出于对这些因素的			

		

	

				

		

			

                《创业家》牛文文：少谈点模式多谈点技术
			

		

		

									

				"模式"如同当年的"主义",流行于各种创业大赛.创业励志节目.论坛的"街头"式秀场 文/创业家 牛文文 "美国某某公司你知道吧?就是刚被戴尔.惠普.思科十几亿美元抢购的那家.我们的模式和它的一样,现在还没赢利,可将来起码有十几亿人民币的市值." "我开了小煤矿,但煤运不出去,上商学院之后受到启发,想搞模式创新,具体讲就是想在铁路边上搞个煤炭物流开发区,建一个大的物流和信息流平台,把分散的煤炭集中在我这个园区,这样和铁			

		

	

				

		

			

                JAVA之旅（十五）——多线程的生产者和消费者，停止线程,守护线程,线程的优先级，setPriority设置优先级，yield临时停止
			

		

		

									

				JAVA之旅(十五)--多线程的生产者和消费者,停止线程,守护线程,线程的优先级,setPriority设置优先级,yield临时停止 我们接着多线程讲 一.生产者和消费者 什么是生产者和消费者?我们解释过来应该是生产一个,消费一个,的意思,具体我们通过例子来说 package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 生产者和消费者