Re-use thread pool threads (#27)

This is as opposed to queuing each actor task on the thread pool. This
improves performance in many cases.

Author: jhickson

Winton.Extensions.Threading.Actor.Tests.Unit/Internal/ActorWorkSchedulerTests.cs

@@ -279,7 +279,7 @@ public void ShouldBeAbleToConfigureScheduleToRescheduleInCaseOfUnexpectedErrorBu
                     throw new Exception($"Unhandled test case {workType}.");
             }
 
-            Within.FiveSeconds(() => times.Should().HaveCount(4));
+            Within.FiveSeconds(() => times.Count.Should().BeGreaterOrEqualTo(4));
 
             emittedException.Should().BeOfType<InvalidOperationException>().Which.Message.Should().Be("Pah!");
 

Winton.Extensions.Threading.Actor.Tests.Unit/Winton.Extensions.Threading.Actor.Tests.Unit.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0" />
     <PackageReference Include="Moq" Version="4.8.1" />
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />

Winton.Extensions.Threading.Actor/Internal/ActorTaskScheduler.cs

@@ -13,11 +13,6 @@ internal sealed class ActorTaskScheduler : TaskScheduler
         [ThreadStatic]
         private static bool _shouldPause;
 
-#if NETSTANDARD1_3
-        [ThreadStatic]
-        private static bool _isNonThreadPoolThread;
-#endif
-
         private readonly ActorId _actorId;
         private readonly object _lockObject = new object();
         private readonly ActorSynchronizationContext _synchronizationContext;
@@ -164,95 +159,87 @@ private void QueueForExecutionOffThreadPool(ActorTask actorTask)
         {
             _thread?.Join();
             _thread =
-#if NETSTANDARD1_3
-                new Thread(x =>
-                           {
-                               _isNonThreadPoolThread = true;
-                               Execute(x);
-                           })
-#else
                 new Thread(Execute)
-#endif
                 {
                     IsBackground = true,
                     Name = "ActorWorker"
                 };
             _thread.Start(actorTask);
         }
 
-        private void QueueOnThreadPool(ActorTask actorTask)
-        {
+        private void QueueOnThreadPool(ActorTask actorTask) =>
 #if NETSTANDARD1_3
             ThreadPool.QueueUserWorkItem(Execute, actorTask);
 #else
             ThreadPool.UnsafeQueueUserWorkItem(Execute, actorTask);
 #endif
-        }
 
         private void Execute(object state)
         {
             var previousSynchronizationContext = PrepareThreadForExecute();
-            
             var actorTask = (ActorTask)state;
-            var task = actorTask.Task;
+            var onLongRunningThread = (actorTask.Task.CreationOptions & TaskCreationOptions.LongRunning) == TaskCreationOptions.LongRunning;
+            var switchThreadType = false;
 
-            var isTerminalTask = (actorTask.Traits & ActorTaskTraits.Terminal) != 0;
+            while (!(actorTask is null) && !switchThreadType)
+            {
+                var task = actorTask.Task;
+                var isTerminalTask = (actorTask.Traits & ActorTaskTraits.Terminal) != 0;
 
-            TryExecuteTask(task);
+                TryExecuteTask(task);
 
-            actorTask.CleanUpPostExecute();
+                actorTask.CleanUpPostExecute();
 
-            CleanUpThreadAfterExecute(previousSynchronizationContext);
+                var shouldTerminate = isTerminalTask || (actorTask.Traits & ActorTaskTraits.Critical) != 0 && task.Status != TaskStatus.RanToCompletion;
 
-            var shouldTerminate = isTerminalTask || (actorTask.Traits & ActorTaskTraits.Critical) != 0 && task.Status != TaskStatus.RanToCompletion;
+                actorTask = null;
 
-            TakeLock();
+                TakeLock();
 
-            if (shouldTerminate)
-            {
-                _status = ActorTaskSchedulerStatus.Terminated;
-                ReleaseLock();
-                TerminationCleanUp(isTerminalTask ? task : null);
-            }
-            else if (_shouldPause && (_front is null || (_front.Traits & ActorTaskTraits.Resuming) == 0))
-            {
-                _status = ActorTaskSchedulerStatus.Paused;
-                ReleaseLock();
-            }
-            else
-            {
-                var nextTask = _front;
-
-                if (nextTask is null)
+                if (shouldTerminate)
                 {
-                    _status = ActorTaskSchedulerStatus.Inactive;
+                    _status = ActorTaskSchedulerStatus.Terminated;
+                    ReleaseLock();
+                    TerminationCleanUp(isTerminalTask ? task : null);
+                }
+                else if (_shouldPause && (_front is null || (_front.Traits & ActorTaskTraits.Resuming) == 0))
+                {
+                    _status = ActorTaskSchedulerStatus.Paused;
                     ReleaseLock();
                 }
                 else
                 {
-                    _front = _front.Next;
-
                     if (_front is null)
                     {
-                        _back = null;
-                    }
-
-                    ReleaseLock();
-
-#if NETSTANDARD1_3
-                    if (_isNonThreadPoolThread)
-#else
-                    if (!Thread.CurrentThread.IsThreadPoolThread)
-#endif
-                    {
-                        Execute(nextTask);
+                        _status = ActorTaskSchedulerStatus.Inactive;
                     }
                     else
                     {
-                        QueueForExecution(nextTask);
+                        _shouldPause = false;
+                        actorTask = _front;
+                        _front = _front.Next;
+
+                        if (_front is null)
+                        {
+                            _back = null;
+                        }
+
+                        if (!onLongRunningThread)
+                        {
+                            switchThreadType = (actorTask.Task.CreationOptions & TaskCreationOptions.LongRunning) == TaskCreationOptions.LongRunning;
+                        }
                     }
+
+                    ReleaseLock();
                 }
             }
+
+            CleanUpThreadAfterExecute(previousSynchronizationContext);
+
+            if (switchThreadType)
+            {
+                QueueForExecution(actorTask);
+            }
         }
 
         private void TerminationCleanUp(Task terminalTask)