What is the difference between Task.Run() and Task.Factory.StartNew()

by

The second method, Task.Run, has been introduced in a later version of the .NET framework (in .NET 4.5).

However, the first method, Task.Factory.StartNew, gives you the opportunity to define a lot of useful things about the thread you want to create, while Task.Run doesn’t provide this.

For instance, lets say that you want to create a long running task thread. If a thread of the thread pool is going to be used for this task, then this could be considered an abuse of the thread pool.

One thing you could do in order to avoid this would be to run the task in a separate thread. A newly created thread that would be dedicated to this task and would be destroyed once your task would have been completed. You cannot achieve this with the Task.Run, while you can do so with the Task.Factory.StartNew, like below:

Task.Factory.StartNew(..., TaskCreationOptions.LongRunning);

As it is stated here:

So, in the .NET Framework 4.5 Developer Preview, we’ve introduced the
new Task.Run method. This in no way obsoletes Task.Factory.StartNew,
but rather should simply be thought of as a quick way to use
Task.Factory.StartNew without needing to specify a bunch of
parameters. It’s a shortcut. In fact, Task.Run is actually
implemented in terms of the same logic used for Task.Factory.StartNew,
just passing in some default parameters. When you pass an Action to
Task.Run:

Task.Run(someAction);

that’s exactly equivalent to:

Task.Factory.StartNew(someAction, 
    CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

More Related Contents:

  1. What is the difference between task and thread?
  2. When to use Task.Delay, when to use Thread.Sleep?
  3. Execute task in background in WPF application
  4. Does the use of async/await create a new thread?
  5. When to use BlockingCollection and when ConcurrentBag instead of List?
  6. Is it considered acceptable to not call Dispose() on a TPL Task object?
  7. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  8. Multiple Parallel.ForEach loops in .Net
  9. Proper way to implement a never ending task. (Timers vs Task)
  10. How to create a task (TPL) running a STA thread?
  11. How to put a task to sleep (or delay) in C# 4.0?
  12. Is Task.Factory.StartNew() guaranteed to use another thread than the calling thread?
  13. Cancelling a pending task synchronously on the UI thread
  14. Does using Tasks (TPL) library make an application multithreaded?
  15. The current SynchronizationContext may not be used as a TaskScheduler
  16. ConfigureAwait pushes the continuation to a pool thread
  17. ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew
  18. Process queue with multithreading or tasks
  19. How to achieve remove_if functionality in .NET ConcurrentDictionary
  20. Calling async methods from non-async code
  21. SynchronizationLockException on Monitor.Exit when using await
  22. Why CancellationToken is separate from CancellationTokenSource?
  23. Should i use ThreadPools or Task Parallel Library for IO-bound operations
  24. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  25. Synchronous implementation of interface that returns Task
  26. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  27. How to properly parallelise job heavily relying on I/O
  28. Why does this Parallel.ForEach code freeze the program up?
  29. Wrapping ManualResetEvent as awaitable task
  30. Calling TaskCompletionSource.SetResult in a non blocking manner

Leave a Comment