Task Parallelism

The Task Parallel Library (TPL) is based on the concept of a task, which represents an asynchronous operation. In
some ways, a task resembles a thread or ThreadPool work item, but at a higher
level of abstraction. The term task parallelism refers to one or more
independent tasks running concurrently. Tasks provide two primary benefits:

• More efficient and more scalable use of system resources.

  Behind the scenes, tasks are queued to the ThreadPool,
  which has been enhanced with algorithms that determine and adjust to the number of threads and that provide load balancing to maximize throughput. This makes tasks relatively lightweight, and you can create many of them
  to enable fine-grained parallelism.

• More programmatic control than is possible with a thread or work item.

  Tasks and the framework built around them provide a rich set of APIs that support waiting, cancellation, continuations, robust exception handling, detailed status, custom scheduling, and more.

For both of these reasons, in the .NET Framework, TPL is the preferred API for writing multi-threaded, asynchronous, and parallel code.

• Creating and Running Tasks Implicitly

The Parallel.Invoke method
provides a convenient way to run any number of arbitrary statements concurrently. Just
pass in an Action delegate for each item of work. The
easiest way to create these delegates is to use lambda expressions. The
lambda expression can either call a named method or provide the code inline. The
following example shows a basic Invoke call that creates
and starts two tasks that run concurrently. The
first task is represented by a lambda expression that calls a method named DoSomeWork, and the second task is represented by a lambda expression that calls a method
named DoSomeOtherWork.

Parallel.Invoke(() => DoSomeWork(), () => DoSomeOtherWork());

The
number of Task instances that are created behind the scenes by Invoke is
not necessarily equal to the number of delegates that are provided. The
TPL may employ various optimizations, especially with large numbers of delegates.

For
greater control over task execution or to return a value from the task, you have to work with Task objects
more explicitly.

• Creating and Running Tasks Explicitly

• A
  task that does not return a value is represented by the System.Threading.Tasks.Task class. A
  task that returns a value is represented by the System.Threading.Tasks.Task<TResult> class, which
  inherits from Task. The
  task object handles the infrastructure details and provides methods and properties that are accessible from the calling thread throughout the lifetime of the task. For
  example, you can access the Status property of a task at any time to
  determine whether it has started running, ran to completion, was canceled, or has thrown an exception. The
  status is represented by a TaskStatus enumeration.
• When
  you create a task, you give it a user delegate that encapsulates the code that the task will execute. The
  delegate can be expressed as a named delegate, an anonymous method, or a lambda expression. Lambda
  expressions can contain a call to a named method, as shown in the following example. Note
  that the example includes a call to the Task.Wait method to ensure that
  the task completes execution before the console mode application ends.
• You
  can also use the Task.Run methods to create and start a task in one operation. To
  manage the task, the Run methods use the default task scheduler, regardless
  of which task scheduler is associated with the current thread. The Run methods
  are the preferred way to create and start tasks when more control over the creation and scheduling of the task is not needed.
• You
  can also use the TaskFactory.StartNew method to create and start
  a task in one operation. Use
  this method when creation and scheduling do not have to be separated and you require additional task creation options or the use of a specific scheduler, or when you need to pass additional state into the task through its AsyncState property,
  as shown in the following example.
• Task and Task<TResult> each
  expose a static Factory property that returns a default instance of TaskFactory,
  so that you can call the method as Task.Factory.StartNew(). Also,
  in the following example, because the tasks are of type System.Threading.Tasks.Task<TResult>, they
  each have a public Task<TResult>.Result property that contains the result of the computation. The
  tasks run asynchronously and may complete in any order. If
  the Result property is accessed before the computation finishes, the property blocks the calling thread until the value
  is available.
• When
  you use a lambda expression to create a delegate, you have access to all the variables that are visible at that point in your source code. However,
  in some cases, most notably within loops, a lambda doesn't capture the variable as expected. It
  only captures the final value, not the value as it mutates after each iteration.

• Waiting for Tasks to Finish

• The System.Threading.Tasks.Task and System.Threading.Tasks.Task<TResult> types
  provide several overloads of the Task.Wait and Task<TResult>.Wait methods
  that enable you to wait for a task to finish. In addition, overloads of the static Task.WaitAll and Task.WaitAny methods
  let you wait for any or all of an array of tasks to finish.
• Typically, you would wait for a task for one of these reasons:
  • The main thread depends on the final result computed by a task.
  • You have to handle exceptions that might be thrown from the task.
  • The application may terminate before all tasks have completed execution. For
    example, console applications will terminate as soon as all synchronous code in Main (the application entry point) has executed.
• When
  you wait for a task, you implicitly wait for all children of that task that were created by using the TaskCreationOptions.AttachedToParent option. Task.Wait returns
  immediately if the task has already completed. Any
  exceptions raised by a task will be thrown by a Wait method, even if the Wait method
  was called after the task completed.