Question

我知道CLR会使每个AppDomain ThreadPool时间片工作，但我想知道是否通过创建一个新的线程Thread t = new Thread(...);

是由CLR管理还是由AppDomin ThreadPool管理？

Answer 1

Thread t = new Thread();不会由ThreadPool管理。但它是CLR在操作系统线程上提供的抽象。 ThreadPool是一个附加的抽象，它有助于重用线程和共享线程资源。

以下是.NET中线程的优秀资源：http://www.albahari.com/threading/

如果您使用的是.NET 4.0，请考虑使用TPL。

Answer 2

当您使用Thread类创建线程时，您处于控制之中。您可以根据需要创建它们，并定义它们是background or foreground（使调用进程保持活动状态），设置Priority，启动和停止它们。

使用ThreadPool或Task（在幕后使用ThreadPool），让ThreadPool类管理线程的创建，并最大化线程的可重用性，为您节省创建新线程所需的时间。需要注意的一点是，与Thread默认值不同，ThreadPool创建的线程不会使调用进程保持活动状态。

使用ThreadPool的一个巨大优势是，您可以让少量线程处理大量任务。相反，假设池没有杀死线程（因为它是为可重用性而设计的），如果你有一堆由ThreadPool创建的线程，但后来项目数量缩小，ThreadPool空闲很多，浪费资源。

Answer 3

创建新主题时，它们不由线程池管理。

Answer 4

如果您手动创建线程然后控制其生命周期，则它独立于线程池。

Answer 5

以下示例显示了如何使用线程池。它首先创建一个ManualResetEvent对象，该对象使程序能够知道线程池何时完成了所有工作项的运行。接下来，它尝试将一个线程添加到线程池。如果成功，则添加其余部分（本例中为4个）。然后，线程池将工作项放入可用线程中。调用eventX上的WaitOne方法，这会导致程序的其余部分等到事件被触发（使用eventX.Set方法）。最后，程序打印出线程上的负载（实际执行特定工作项的线程）。

    // SimplePool.cs
// Simple thread pool example
using System;
using System.Collections;
using System.Threading;

// Useful way to store info that can be passed as a state on a work item
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;
   }

   // Beta is the method that will be called when the work item is
   // serviced on the thread pool.
   // That means this method will be called when the thread pool has
   // an available thread for the work item.
   public void Beta(Object state)
   {
      // Write out the hashcode and cookie for the current thread
      Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(),
         ((SomeState)state).Cookie);
      // The lock keyword allows thread-safe modification
      // of variables accessible across multiple threads.
      Console.WriteLine(
         "HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}",
         HashCount.Count, 
         Thread.CurrentThread.GetHashCode());
      lock (HashCount) 
      {
         if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
            HashCount.Add (Thread.CurrentThread.GetHashCode(), 0);
         HashCount[Thread.CurrentThread.GetHashCode()] = 
            ((int)HashCount[Thread.CurrentThread.GetHashCode()])+1;
      }

      // Do some busy work.
      // Note: Depending on the speed of your machine, if you 
      // increase this number, the dispersement of the thread
      // loads should be wider.
      int iX  = 2000;
      Thread.Sleep(iX);
      // The Interlocked.Increment method allows thread-safe modification
      // of variables accessible across multiple threads.
      Interlocked.Increment(ref iCount);
      if (iCount == iMaxCount)
      {
         Console.WriteLine();
         Console.WriteLine("Setting eventX ");
         eventX.Set();
      }
   }
}

public class SimplePool
{
   public static int Main(string[] args)
   {
      Console.WriteLine("Thread Pool Sample:");
      bool W2K = false;
      int MaxCount = 10;  // Allow a total of 10 threads in the pool
      // Mark the event as unsignaled.
      ManualResetEvent eventX = new ManualResetEvent(false);
      Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount);
      Alpha oAlpha = new Alpha(MaxCount);  // Create the work items.
      // Make sure the work items have a reference to the signaling event.
      oAlpha.eventX = eventX;
      Console.WriteLine("Queue to Thread Pool 0");
      try
      {
         // Queue the work items, which has the added effect of checking
         // which OS is running.
         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-Windows 2000 system.");
         W2K = false;
      }
      if (W2K)  // If running on an OS which supports the ThreadPool methods.
      {
         for (int iItem=1;iItem < MaxCount;iItem++)
         {
            // Queue the work items:
            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");
         // The call to exventX.WaitOne sets the event to wait until
         // eventX.Set() occurs.
         // (See oAlpha.Beta).
         // Wait until event is fired, meaning eventX.Set() was called:
         eventX.WaitOne(Timeout.Infinite,true);
         // The WaitOne won't return until the event has been signaled.
         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]);
      }
      return 0;
   }
}

Out put

Thread Pool Sample:
Queuing 10 items to Thread Pool
Queue to Thread Pool 0
Queue to Thread Pool 1
...
...
Queue to Thread Pool 9
Waiting for Thread Pool to drain
 98 0 :
HashCount.Count==0, Thread.CurrentThread.GetHashCode()==98
 100 1 :
HashCount.Count==1, Thread.CurrentThread.GetHashCode()==100
 98 2 :
...
...
Setting eventX
Thread Pool has been drained (Event fired)

Load across threads
101 2
100 3
98 4
102 1

线程是否由线程池管理？

5 个答案: