Understanding Async/Await pattern for multi-tasking

Question

Currently, i am having difficulties to understand multi-tasking using async and await pattern. In order to get some basics, i have written the following test case;

public partial class MainWindow : Window
{

    public MainWindow()
    {
        InitializeComponent();
    }

    private int global_int = 10;
    public async Task<int> RunAsyncTask()
    {
       // This method runs asynchronously.
       await Task.Run(() => Calculate());
       return global_int;
    }

    private int Calculate()
    {
        Console.WriteLine("Ticket count: " + --global_int);
        return global_int;
    }

    private async void  Start_Button_Click(object sender, RoutedEventArgs e)
    {
        List<Task<int>> list = new List<Task<int>>(); 

        Console.WriteLine("\nReseting: " );
        global_int = 10;

        for (int i = 0; i < 10; i++)
        {
            var task = RunAsyncTask();
            list.Add(task); 
        }

       await Task.WhenAll(list.ToArray<Task<int>>()); 
        
       Console.WriteLine("\nFinished: " + global_int);

    }
}

Idea/Target:

10 customers, 10 tickets, every customer buys a ticket and at the end there will be no availiable ticket.

Problem:

When I run the code, i am actually getting not always the same result (Expecting 0 ticket always). Where is the actuall problem?

So, how can I write the code in a way that, result would be always same.

Output1:

Reseting: 
Ticket count: 9
Ticket count: 8
Ticket count: 8
Ticket count: 7
Ticket count: 5
Ticket count: 6
Ticket count: 4
Ticket count: 3
Ticket count: 2
Ticket count: 1

Finished: 1

Output2:

Reseting: 
Ticket count: 9
Ticket count: 8
Ticket count: 7
Ticket count: 6
Ticket count: 5
Ticket count: 4
Ticket count: 3
Ticket count: 2
Ticket count: 1
Ticket count: 0

Finished: 0

Answer 1

--global_int

This is not a thread-safe operation. Multiple threads are reading and writing to global_int, causing a race condition. There's a handy class called Interlocked to keep simple int operations atomic, change your Calculate method to:

Console.WriteLine("Ticket count: " + Interlocked.Decrement(ref global_int);

Answer 2

If you want to understand how tasks might be scheduled in a single-threaded fashion while still making use of async patterns, you may be interested in this code.

class Program
{
   static void Main(string[] args)
   {
     InitiateCalculations().Wait();
     Console.WriteLine("Finished: {0}", global_int);
   }

   // LimitedConcurrencyLevelTaskScheduler from
   // https://msdn.microsoft.com/en-us/library/system.threading.tasks.taskscheduler
   // Provides a task scheduler that ensures a maximum concurrency level while 
   // running on top of the thread pool.
   public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
   {
      public static TaskFactory SingleFactory { get; private set; }

      static LimitedConcurrencyLevelTaskScheduler()
      {
         SingleFactory = new TaskFactory(new LimitedConcurrencyLevelTaskScheduler(1));
      }

      // Indicates whether the current thread is processing work items.
      [ThreadStatic]
      private static bool _currentThreadIsProcessingItems;

      // The list of tasks to be executed 
      private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)

      // The maximum concurrency level allowed by this scheduler. 
      private readonly int _maxDegreeOfParallelism;

      // Indicates whether the scheduler is currently processing work items. 
      private int _delegatesQueuedOrRunning = 0;

      // Creates a new instance with the specified degree of parallelism. 
      public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
      {
         if (maxDegreeOfParallelism < 1) throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
         _maxDegreeOfParallelism = maxDegreeOfParallelism;
      }

      // Queues a task to the scheduler. 
      protected sealed override void QueueTask(Task task)
      {
         // Add the task to the list of tasks to be processed.  If there aren't enough 
         // delegates currently queued or running to process tasks, schedule another. 
         lock (_tasks)
         {
            _tasks.AddLast(task);
            if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
            {
               ++_delegatesQueuedOrRunning;
               NotifyThreadPoolOfPendingWork();
            }
         }
      }
      // Inform the ThreadPool that there's work to be executed for this scheduler. 
      private void NotifyThreadPoolOfPendingWork()
      {
         ThreadPool.UnsafeQueueUserWorkItem(_ =>
         {
            // Note that the current thread is now processing work items.
            // This is necessary to enable inlining of tasks into this thread.
            _currentThreadIsProcessingItems = true;
            try
            {
               // Process all available items in the queue.
               while (true)
               {
                  Task item;
                  lock (_tasks)
                  {
                     // When there are no more items to be processed,
                     // note that we're done processing, and get out.
                     if (_tasks.Count == 0)
                     {
                        --_delegatesQueuedOrRunning;
                        break;
                     }

                     // Get the next item from the queue
                     item = _tasks.First.Value;
                     _tasks.RemoveFirst();
                  }

                  // Execute the task we pulled out of the queue
                  base.TryExecuteTask(item);
               }
            }
            // We're done processing items on the current thread
            finally { _currentThreadIsProcessingItems = false; }
         }, null);
      }

      // Attempts to execute the specified task on the current thread. 
      protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
      {
         // If this thread isn't already processing a task, we don't support inlining
         if (!_currentThreadIsProcessingItems) return false;

         // If the task was previously queued, remove it from the queue
         if (taskWasPreviouslyQueued)
            // Try to run the task. 
            if (TryDequeue(task))
               return base.TryExecuteTask(task);
            else
               return false;
         else
            return base.TryExecuteTask(task);
      }

      // Attempt to remove a previously scheduled task from the scheduler. 
      protected sealed override bool TryDequeue(Task task)
      {
         lock (_tasks) return _tasks.Remove(task);
      }

      // Gets the maximum concurrency level supported by this scheduler. 
      public sealed override int MaximumConcurrencyLevel { get { return _maxDegreeOfParallelism; } }

      // Gets an enumerable of the tasks currently scheduled on this scheduler. 
      protected sealed override IEnumerable<Task> GetScheduledTasks()
      {
         bool lockTaken = false;
         try
         {
            Monitor.TryEnter(_tasks, ref lockTaken);
            if (lockTaken) return _tasks;
            else throw new NotSupportedException();
         }
         finally
         {
            if (lockTaken) Monitor.Exit(_tasks);
         }
      }
   }

   static private int global_int = 10;
   public static Task<int> RunAsyncTask()
   {
      return LimitedConcurrencyLevelTaskScheduler.SingleFactory.StartNew<int>(Calculate);
   }

   private static int Calculate()
   {
      Thread.Sleep(500);
      Console.WriteLine("Ticket count: {0} Thread: {1}", --global_int, Thread.CurrentThread.ManagedThreadId);
      return global_int;
   }

   private static async Task InitiateCalculations()
   {
      List<Task<int>> list = new List<Task<int>>();

      Console.WriteLine("\nReseting: ");
      global_int = 10;

      for (int i = 0; i < 10; i++)
      {
         var task = RunAsyncTask();
         list.Add(task);
      }

      await Task.WhenAll(list.ToArray<Task<int>>());
   }
}