In this synchronous code fragment, LongOperationC() won’t start execution until LongOprationB() and LongOperationA() completes. During the time that each of these methods are executed the calling thread is blocked and the resources it holds are practically wasted and cannot be utilized to serve other requests or handle other events. If this was happening on the UI thread then the application would look frozen until the execution finish.

If this was happening on a server application, then at some point we might run out of free threads and requests would start being rejected. In both of those cases the application stops being responsive.

The total time it takes to run the code fragment above is 

total_time = LongOperationA_time + LongOperationB_time + LongOperationC_time

The total completion time is the sum of the completion time of its components.

If we could start an operation without waiting for a previous operation to complete, we could utilize our resources much better, this is what asynchronous execution is for.

Asynchronous execution means that an operation is started, but its execution is happening in the background and the caller isn’t blocked. Instead the caller is notified when the operation is completed. In that time the caller can continue to do useful work.  

In the food ordering example, an asynchronous approach will be similar to sitting at the table and being served by a waiter.

First, you sit at the table, the waiter comes to hand you the menu and leaves. While you’re deciding what to order the waiter is still available to other customers. When you decide what meal you want, the waiter comes back and takes your order. While the food is being prepared, you’re free to chat, use your phone, or enjoy the view. You’re not blocked (and neither is the waiter). When the food is ready, the waiter brings it to your table and goes back to serve other customers until you request the bill and pay.

This model is asynchronous, tasks are executed concurrently, and the time of execution is different from the time of the request, this way the resources (such as the waiter) are free to handle more requests.

Where the Asynchronous Execution Happens

In a computer program, we can differentiate between two types of asynchronous operations, IO based and CPU based.

CPU-based operation means that the asynchronous code will run on another thread and the result will be returned when the execution on the other thread finishes.

IO-based operation means that the operation is made on an IO device such as a hard drive or network. If network is the case, a request was made to another machine (by using TCP or UDP or other network protocol) and when the operating system on your machine gets a signal from the network hardware by an interrupt that the result came back then the operation will be completed. 

The calling thread in both of the cases is free to execute other tasks and handle other requests and event.

There’s more than one way to run code asynchronously, and it depends on the language that’s used. For now let’s look at one example of doing asynchronous work using the .NET implementation of Futures – the Task class. 

The asynchronous version of the code fragment above will look like the following code:

taskA=LongOperationAAsync(); 
taskB=LongOperationBAsync(); 
taskC=LongOpertionsCAsync(); 
Task.WaitAll(taskA, taskB, taskC); 

taskA=LongOperationAAsync(); 
taskB=LongOperationBAsync(); 
taskC=LongOpertionsCAsync(); 
taskA.Wait(); 
taskB.Wait();  
taskC.Wait(); 

IObservable<Connectivity> myConnectivity=...   
  IObservable<IEnumerable<Discount>> newDiscounts = 
  from connectiviy in myConnectivity
  where connectiviy == Connectivity.Online
  from discounts in GetDiscounts()
  select discounts; 
newDiscounts.Subscribe(discounts => RefreshView(discounts)); 

private Task<IEnumerable<Discount>> GetDiscounts() { 
    //Send request to the server and receives the collection of discounts 
}