创建线程 - Task.Factory.StartNew vs new Thread（）

Question

I am just learning about the new Threading and Parallel libraries in .Net 4

In the past I would create a new Thread like so (as an example):

DataInThread = new Thread(new ThreadStart(ThreadProcedure));
DataInThread.IsBackground = true;
DataInThread.Start();

Now I can do:

Task t = Task.Factory.StartNew(() =>
{
   ThreadProcedure();
});

What is the difference if any?

Thanks

Answer 1

There is a big difference. Tasks are scheduled on the ThreadPool and could even be executed synchronous if appropiate.

If you have a long running background work you should specify this by using the correct Task Option.

You should prefer Task Parallel Library over explicit thread handling, as it is more optimized. Also you have more features like Continuation.

Answer 2

The task gives you all the goodness of the task API:

• Adding continuations ( Task.ContinueWith )
• Waiting for multiple tasks to complete (either all or any)
• Capturing errors in the task and interrogating them later
• Capturing cancellation (and allowing you to specify cancellation to start with)
• Potentially having a return value
• Using await in C# 5
• Better control over scheduling (if it's going to be long-running, say so when you create the task so the task scheduler can take that into account)

Note that in both cases you can make your code slightly simpler with method group conversions:

DataInThread = new Thread(ThreadProcedure);
// Or...
Task t = Task.Factory.StartNew(ThreadProcedure);

Answer 3

In the first case you are simply starting a new thread while in the second case you are entering in the thread pool.

The thread pool job is to share and recycle threads. It allows to avoid losing a few millisecond every time we need to create a new thread.

There are a several ways to enter the thread pool:

• with the TPL (Task Parallel Library) like you did
• by calling ThreadPool.QueueUserWorkItem
• by calling BeginInvoke on a delegate
• when you use a BackgroundWorker

Answer 4

Your first block of code tells CLR to create a Thread (say. T) for you which is can be run as background (use thread pool threads when scheduling T ). In concise, you explicitly ask CLR to create a thread for you to do something and call Start() method on thread to start.

Your second block of code does the same but delegate (implicitly handover) the responsibility of creating thread (background- which again run in thread pool) and the starting thread through StartNew method in the Task Factory implementation.

This is a quick difference between given code blocks. Having said that, there are few detailed difference which you can google or see other answers from my fellow contributors.