线程是否由线程池管理？

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类创建线程时， 您可以控制。 您可以根据需要创建它们，并定义它们是后台还是前景 （使调用进程保持活动状态），设置Priority ，启动和停止它们。

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

使用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;
   }
}

出局

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