54

If I have the following block of code in a method (using .NET 4 and the Task Parallel Library):

var task = new Task(() => DoSomethingLongRunning());
task.Start();

and the method returns, will that task go out of scope and be garbage collected, or will it run to completion? I haven't noticed any issues with GCing, but want to make sure I'm not setting myself up for a race condition with the GC.

kemiller2002
  • 113,795
  • 27
  • 197
  • 251
Hank
  • 8,289
  • 12
  • 47
  • 57
  • I found a small thing about this after a while and I thought I'd share with you, for completeness sake... See the update below. – Bruno Brant Jan 20 '14 at 18:51

2 Answers2

37

Update:

After I answered this question (a long time ago!) I found out that it's not true that Tasks will always run to completion - there's a small, let's say "corner" case, where tasks may not finish.

The reason for that is this: As I have answered previously, Tasks are essentially threads; but they are background threads. Background threads are automatically aborted when all foreground threads finish. So, if you don't do anything with the task and the program ends, there's a chance the task won't complete.

You should always await on tasks. More information can be found on the excellent answer Jon gave me.

Original:

Task are scheduled to the ThreadPool, meaning that they are essentially threads¹ (actually, they encapsulate threads).

From the Thread documentation:

It is not necessary to retain a reference to a Thread object once you have started the thread. The thread continues to execute until the thread procedure is complete.

So, no, there is no need to retain a reference to it.

Also, the documentation states that the preferred way to create a Task is to use it's factory:

You can also use the StartNew method to create and start a task in one operation. This is the preferred way to create and start tasks if creation and scheduling do not have to be separated (...)

Hope it helps.

¹ Accordingly to the documentation:

A task represents an asynchronous operation, and in some ways it resembles the creation of a new thread or ThreadPool work item, but at a higher level of abstraction.

Community
  • 1
  • 1
Bruno Brant
  • 8,226
  • 7
  • 45
  • 90
16

The task will run to completion. Even if there aren't any other references to it (not being rooted I believe is the term), the thread pool will still hold a reference to it, and prevent it from being Garbage Collected at least (I say at least, because even after it completes, there is no guarantee that it will be Garbage Collected) until completion.

kemiller2002
  • 113,795
  • 27
  • 197
  • 251
  • Yes, `rooted` is the correct term. As long as *something* has a valid (live) reference to the task instance it will not be eligible for collection. In this case, the thread pool itself will hold that reference until the thread completes. – Scott Dorman May 06 '10 at 17:02
  • 7
    To be more accurate, the TPL's task scheduler will have a reference to the task while it is running. Without out that reference, the task might be garbage collected, but that won't stop the code that runs from finishing. – Steven May 06 '10 at 17:36