Monitor performance ~30x slower #115989

[MaxIterationCount(30)]
public class MultiThreadBenchmark
{
    private readonly MyThreadPoolSynchronizationContext _alternativeThreadPool = new MyThreadPoolSynchronizationContext();

    [Benchmark]
    [Arguments(2)]
    [Arguments(7)]
    public void MultiThreadTest(int postCount)
    {
        for (int i = 0; i < postCount; ++i)
        {
            _alternativeThreadPool.Post(_ => { }, null);
        }
        _alternativeThreadPool.WaitForAllThreadsToComplete();
    }
}


public sealed class MyThreadPoolSynchronizationContext : SynchronizationContext
{
    volatile private int _runningActionCount;

    private sealed class ThreadRunner
    {
        private static readonly Stack<ThreadRunner> s_pool = new Stack<ThreadRunner>();
        private static int s_threadCounter;

        private MyThreadPoolSynchronizationContext _owner;
        private readonly object _locker = new object();
        private SendOrPostCallback _callback;
        private object _state;

        public static void Run(MyThreadPoolSynchronizationContext owner, SendOrPostCallback callback, object state)
        {
            Interlocked.Increment(ref owner._runningActionCount);
            bool reused = false;
            ThreadRunner threadRunner = null;
            lock (s_pool)
            {
                if (s_pool.Count > 0)
                {
                    reused = true;
                    threadRunner = s_pool.Pop();
                }
            }
            if (!reused)
            {
                threadRunner = new ThreadRunner();
            }
            lock (threadRunner._locker)
            {
                threadRunner._owner = owner;
                threadRunner._callback = callback;
                threadRunner._state = state;
                if (reused)
                {
                    Monitor.Pulse(threadRunner._locker);
                }
                else
                {
                    new Thread(threadRunner.ThreadAction)
                    {
                        IsBackground = true,
                        Name = $"MyThreadPoolSynchronizationContext_{Interlocked.Increment(ref s_threadCounter)}"
                    }.Start();
                }
            }
        }

        private void ThreadAction()
        {
            SetSynchronizationContext(_owner);

            while (true)
            {
                MyThreadPoolSynchronizationContext owner = _owner;
                SendOrPostCallback callback = _callback;
                object state = _state;
                // Allow GC to reclaim memory.
                _owner = null;
                _callback = null;
                _state = null;
                callback.Invoke(state);
                Interlocked.Decrement(ref owner._runningActionCount);
                lock (_locker)
                {
                    lock (s_pool)
                    {
                        s_pool.Push(this);
                    }
                    Monitor.Wait(_locker);
                }
            }
        }
    }

    public void WaitForAllThreadsToComplete()
    {
        var spinner = new SpinWait();
        while (_runningActionCount > 0)
        {
            spinner.SpinOnce();
        }
    }

    public override SynchronizationContext CreateCopy()
    {
        return this;
    }

    public override void Post(SendOrPostCallback d, object state)
    {
        if (d == null)
        {
            throw new System.ArgumentNullException("d", "SendOrPostCallback may not be null.");
        }

        ThreadRunner.Run(this, d, state);
    }

    public override void Send(SendOrPostCallback d, object state)
    {
        throw new System.InvalidOperationException();
    }
}