C# 多线程的自动管理(线程池) 基于Task的方式

C# 多线程的自动管理(线程池)

在多线程的程序中，经常会出现两种情况： 
   1. 应用程序中线程把大部分的时间花费在等待状态，等待某个事件发生，然后给予响应。这一般使用 ThreadPool（线程池）来解决。  
   2. 线程平时都处于休眠状态，只是周期性地被唤醒。这一般使用 Timer（定时器）来解决。

ThreadPool 类提供一个由系统维护的线程池（可以看作一个线程的容器），该容器需要 Windows 2000 以上系统支持，因为其中某些方法调用了只有高版本的Windows 才有的 API 函数。

将线程安放在线程池里，需使用 ThreadPool.QueueUserWorkItem() 方法，该方法的原型如下： 
    // 将一个线程放进线程池，该线程的 Start() 方法将调用 WaitCallback 代理对象代表的函数 
    public static bool QueueUserWorkItem(WaitCallback); 
    // 重载的方法如下，参数 object 将传递给 WaitCallback 所代表的方法 
    public static bool QueueUserWorkItem(WaitCallback, object); 
注意： 
    ThreadPool 类是一个静态类，你不能也不必要生成它的对象。而且一旦使用该方法在线程池中添加了一个项目，那么该项目将是无法取消的。这里你无需自己建立线程，只需把你要做的工作写成函数，然后作为参数传递给ThreadPool.QueueUserWorkItem()方法就行了，传递的方法就是依靠 WaitCallback 代理对象，而线程的建立、管理、运行等工作都是由系统自动完成的，你无须考虑那些复杂的细节问题。

ThreadPool 的用法： 
    首先程序创建了一个 ManualResetEvent 对象，该对象就像一个信号灯，可以利用它的信号来通知其它线程。本例中，当线程池中所有线程工作都完成以后，ManualResetEvent 对象将被设置为有信号，从而通知主线程继续运行。 
ManualResetEvent 对象有几个重要的方法： 
    初始化该对象时，用户可以指定其默认的状态（有信号/无信号）； 
    在初始化以后，该对象将保持原来的状态不变，直到它的 Reset() 或者 Set() 方法被调用： 
    Reset()： 
        将其设置为无信号状态； 
    Set()： 
        将其设置为有信号状态。 
    WaitOne()： 
        使当前线程挂起，直到 ManualResetEvent 对象处于有信号状态，此时该线程将被激活。然后，程序将向线程池中添加工作项，这些以函数形式提供的工作项被系统用来初始化自动建立的线程。当所有的线程都运行完了以后，ManualResetEvent.Set() 方法被调用，因为调用了 ManualResetEvent.WaitOne() 方法而处在等待状态的主线程将接收到这个信号，于是它接着往下执行，完成后边的工作。

using System;

using System.Collections;

using System.Threading;

namespace ThreadExample

{

    /// <summary>

    /// 这是用来保存信息的数据结构，将作为参数被传递

    /// </summary>

    public class SomeState

    {

        public int Cookie;

        public SomeState(int iCookie)

        {

            Cookie = iCookie;

        }

    }

    public class Alpha

    {

        public Hashtable HashCount;

        public ManualResetEvent eventX;

        public static int iCount = 0;

        public static int iMaxCount = 0;

        public Alpha(int MaxCount)

        {

            HashCount = new Hashtable(MaxCount);

            iMaxCount = MaxCount;

        }

        /// <summary>

        /// 线程池里的线程将调用 Beta()方法

        /// </summary>

        /// <param name="state"></param> 

        public void Beta(Object state)

        {

            // 输出当前线程的 hash 编码值和 Cookie 的值 

            Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(), ((SomeState)state).Cookie);

            Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHash Code()=={1}", HashCount.Count, 

                Thread.CurrentThread.GetHashCode());

            lock (HashCount)

            {

                // 如果当前的 Hash 表中没有当前线程的 Hash 值，则添加之 

                if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))

                    HashCount.Add(Thread.CurrentThread.GetHashCode(), 0);

                HashCount[Thread.CurrentThread.GetHashCode()] = ((int)HashCount[Thread.CurrentThread.GetHashCode()]) + 1;

            }

            Thread.Sleep(2000);

            // Interlocked.Increment() 操作是一个原子操作，具体请看下面说明 

            Interlocked.Increment(ref iCount);

            if (iCount == iMaxCount)

            {

                Console.WriteLine();

                Console.WriteLine("Setting eventX "); 

                eventX.Set();

            }

        }

    }

    public class SimplePool

    {

        public static void Main(string[] args)

        {

            Console.WriteLine("Thread Pool Sample:");

            bool W2K = false;

            // 允许线程池中运行最多 10 个线程 

            int MaxCount = 10;

            // 新建 ManualResetEvent 对象并且初始化为无信号状态 

            ManualResetEvent eventX = new ManualResetEvent(false);

            Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount);

            // 注意初始化 oAlpha 对象的 eventX 属性 

            Alpha oAlpha = new Alpha(MaxCount);            

            oAlpha.eventX = eventX;

            Console.WriteLine("Queue to Thread Pool 0");

            try

            {

                // 将工作项装入线程池 

                // 这里要用到 Windows 2000 以上版本才有的 API，所以可能出现 NotSupp ortException 异常 

                ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(0));

                W2K = true;

            }

            catch (NotSupportedException)

            {

                Console.WriteLine("These API's may fail when called on a non-Wind ows 2000 system.");

                W2K = false;

            }

            if (W2K) // 如果当前系统支持 ThreadPool 的方法. 

            {

                for (int iItem = 1; iItem < MaxCount; iItem++)

                {

                    // 插入队列元素 

                    Console.WriteLine("Queue to Thread Pool {0}", iItem);

                    ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(iItem));

                }

                Console.WriteLine("Waiting for Thread Pool to drain");

                // 等待事件的完成，即线程调用 ManualResetEvent.Set() 方法 

                eventX.WaitOne(Timeout.Infinite, true);

                // WaitOne() 方法使调用它的线程等待直到 eventX.Set() 方法被调用 

                Console.WriteLine("Thread Pool has been drained (Event fired)");

                Console.WriteLine();

                Console.WriteLine("Load across threads");

                foreach (object o in oAlpha.HashCount.Keys)

                {

                    Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]);

                }

            }

            Console.ReadLine();

        }

    }

}

程序中应该引起注意的地方： 
    SomeState 类是一个保存信息的数据结构，它作为参数被传递给每一个线程，因为你需要把一些有用的信息封装起来提供给线程，而这种方式是非常有效的。 
    程序出现的 InterLocked 类也是专为多线程程序而存在的，它提供了一些有用的原子操作。原子操作：就是在多线程程序中，如果这个线程调用这个操作修改一个变量，那么其他线程就不能修改这个变量了，这跟 lock 关键字在本质上是一样的。

 

 

 

 

 

 

 

WINDOWS操作系统中可以允许最大的线程数

默认情况下，一个线程的栈要预留1M的内存空间 
而一个进程中可用的内存空间只有2G，所以理论上一个进程中最多可以开2048个线程 
但是内存当然不可能完全拿来作线程的栈，所以实际数目要比这个值要小。 
你也可以通过连接时修改默认栈大小，将其改的比较小，这样就可以多开一些线程。 
如将默认栈的大小改成512K，这样理论上最多就可以开4096个线程。

即使物理内存再大，一个进程中可以起的线程总要受到2GB这个内存空间的限制。 
比方说你的机器装了64GB物理内存，但每个进程的内存空间还是4GB，其中用户态可用的还是2GB。

如果是同一台机器内的话，能起多少线程也是受内存限制的。每个线程对象都要站用非页面内存，而非页面内存也是有限的，当非页面内存被耗尽时，也就无法创建线程了。

如果物理内存非常大，同一台机器内可以跑的线程数目的限制值会越来越大。

在Windows下写个程序，一个进程Fork出2000个左右线程就会异常退出了，为什么？

这个问题的产生是因为windows32位系统，一个进程所能使用的最大虚拟内存为2G，而一个线程的默认线程栈StackSize为1024K（1M），这样当线程数量逼近2000时，2000*1024K=2G(大约），内存资源就相当于耗尽。

MSDN原文：

“The number of threads a process can create is limited by the available virtual memory. By default, every thread has one megabyte of stack space. Therefore, you can create at most 2,028 threads. If you reduce the default stack size, you can create more threads. However, your application will have better performance if you create one thread per processor and build queues of requests for which the application maintains the context information. A thread would process all requests in a queue before processing requests in the next queue.”

如何突破2000个限制？

可以通过修改CreateThread参数来缩小线程栈StackSize，例如

#define   MAX_THREADS   50000

DWORD   WINAPI   ThreadProc(   LPVOID   lpParam   ){

while(1){

Sleep(100000);

}

return   0;

}

int   main()   {

DWORD   dwThreadId[MAX_THREADS];

HANDLE   hThread[MAX_THREADS];

for(int   i   =   0;   i   <   MAX_THREADS;   ++i)

{

hThread[i]  = CreateThread(0,  64, ThreadProc, 0, STACK_SIZE_PARAM_IS_A_RESERVATION,   &dwThreadId[i]);

if(0   ==   hThread[i])

{

DWORD   e   =   GetLastError();

printf("%d\r\n",e);

break;

}

}

ThreadProc(0);

}

服务器端程序设计

如果你的服务器端程序设计成：来一个client连接请求则创建一个线程，那么就会存在2000个限制（在硬件内存和CPU个数一定的情况下）。建议如下：

The "one thread per client" model is well-known not to scale beyond a dozen clients or so. If you're going to be handling more than that many clients simultaneously, you should move to a model where instead of dedicating a thread to a client, you instead allocate an object. (Someday I'll muse on the duality between threads and objects.) Windows provides I/O completion ports and a thread pool to help you convert from a thread-based model to a work-item-based model.

1. Serve many clients with each thread, and use nonblocking I/O and level-triggeredreadiness notification

2. Serve many clients with each thread, and use nonblocking I/O and readinesschange notification

3. Serve many clients with each server thread, and use asynchronous I/O