Thread.Start() versus ThreadPool.QueueUserWorkItem()

Question

The Microsoft .NET Base Class Library provides several ways to create a thread and start it. Basically the invocation is very similar to every other one providing the same kind of service: create an object representing an execution flow (or more), assign it a delegate representing the execution flow to execute and, eventually, depending on delegate signature, an object as a parameter.

Well, there are two approaches (essentially):

1) Using the System.Threading.Thread class.

Thread curr = new Thread(myfunction); /* In a class, myfunction is a void taking an object */ curr.Start(new Object()); /* Or something else to be downcast */ 

2) Using the System.Threading.ThreadPool class.

ThreadPool.QueueUserWorkItem(myfunction, new Object()); /* Same philosophy here */ 

Are there any special reasons why I should use 1) or 2)?

• Performance reasons?
• Patterns?
• What is the best approach?

I have a feeling that the answer is: "Depend by the situation". Could you please list some situations where one approach is better than another?

Answer 1

Starting a new thread can be a very expensive operation. The thread pool reuses threads and thus amortizes the cost. Unless you need a dedicated thread, the thread pool is the recommended way to go. By using a dedicated thread you have more control over thread specific attributes such as priority, culture and so forth. Also, you should not do long running tasks on the thread pool as it will force the pool to spawn additional threads.

In addition to the options you mention .NET 4 offers some great abstractions for concurrency. Check out the Task and Parallel classes as well as all the new PLINQ methods.

Answer 2

The Managed Thread Pool has some very good guidelines on when NOT to use the thread pool.

In my experience, you want to create your own thread when you need a persistent, dedicated, long-running thread. For everything else, use asynchronous delegates or something like QueueUserWorkItem, BackgroundWorker, or the Task-related features of .NET 4.0.