Fixed deadlock bug in WorkerScheduler

Author: Matthiee

UpdateLib/UpdateLib/Tasks/WorkerScheduler.cs

@@ -36,9 +36,9 @@ public static WorkerScheduler Instance
 
         private readonly long MAX_WORKERS;
         private readonly ConcurrentQueue<AsyncTask> m_taskQueue;
-        private long m_currentWorkerCount;
+        private readonly AtomicInteger m_currentWorkerCount;
         private readonly AsyncTask m_dispatcherTask;
-        private ManualResetEvent m_waitForAvailableWorker;
+        private readonly ManualResetEvent m_waitForAvailableWorker;
 
         #endregion
 
@@ -48,6 +48,7 @@ private WorkerScheduler()
             m_taskQueue = new ConcurrentQueue<AsyncTask>();
             m_dispatcherTask = AsyncTaskFactory.From(new Action(Dispatcher), null);
             m_waitForAvailableWorker = new ManualResetEvent(true);
+            m_currentWorkerCount = new AtomicInteger();
         }
 
         public void Schedule(AsyncTask task)
@@ -67,18 +68,14 @@ private void Dispatcher()
                 if (task.IsCompleted || task.IsCancelled || task.HasErrors)
                     continue;
 
-                if (m_currentWorkerCount >= MAX_WORKERS)
-                    m_waitForAvailableWorker.Reset();
-
-                m_waitForAvailableWorker.WaitOne();
-
                 SetupTask(task);
 
-                m_currentWorkerCount++;
-                if (m_currentWorkerCount >= MAX_WORKERS)
+                if (m_currentWorkerCount.Value >= MAX_WORKERS)
                     m_waitForAvailableWorker.Reset();
 
-                Logger.Debug(GetType().Name, $"Current worker count: {m_currentWorkerCount}");
+                m_waitForAvailableWorker.WaitOne();
+
+                Logger.Debug(GetType().Name, $"Current worker count: {m_currentWorkerCount.Increment()}");
 
                 task.ConfigureAwait(false).Start();
             }
@@ -88,8 +85,8 @@ private void SetupTask(AsyncTask task)
         {
             task.TaskCompleted += (o, e) =>
             {
-                m_currentWorkerCount--;
-                if (m_currentWorkerCount < MAX_WORKERS)
+
+                if (m_currentWorkerCount.Decrement() < MAX_WORKERS)
                     m_waitForAvailableWorker.Set();
 
                 Logger.Debug(GetType().Name, $"Current worker count: {m_currentWorkerCount}");

UpdateLib/UpdateLib/Threading/AtomicInteger.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MatthiWare.UpdateLib.Threading
+{
+    public class AtomicInteger
+    {
+        private int m_value;
+        private readonly object sync = new object();
+
+        public int Value
+        {
+            get
+            {
+                lock (sync)
+                    return m_value;
+            }
+            set
+            {
+                lock (sync)
+                    m_value = value;
+            }
+        }
+
+        public AtomicInteger()
+            : this(0)
+        { }
+
+        public AtomicInteger(int startingValue)
+        {
+            m_value = startingValue;
+        }
+
+        public int Increment()
+        {
+            lock (sync)
+                return ++m_value;
+        }
+
+        public int Decrement()
+        {
+            lock (sync)
+                return --m_value;
+        }
+
+        public override string ToString()
+        {
+            return Value.ToString();
+        }
+    }
+}

UpdateLib/UpdateLib/UpdateLib.csproj

@@ -84,6 +84,7 @@
     </Compile>
     <Compile Include="Tasks\UpdateCacheTask.cs" />
     <Compile Include="Tasks\WorkerScheduler.cs" />
+    <Compile Include="Threading\AtomicInteger.cs" />
     <Compile Include="Threading\ConcurrentQueue.cs" />
     <Compile Include="UI\Components\ChangelogPage.cs">
       <SubType>UserControl</SubType>