using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static int sharedStateUseConcurrencyLevel = 0;

        static void WorkWithSharedState()
        {
            var concurrencyLevel = Interlocked.Increment(ref sharedStateUseConcurrencyLevel);
            if (concurrencyLevel > 1)
                Console.WriteLine("concurrencyLevel > 1");
            Thread.Sleep(10);
            Interlocked.Decrement(ref sharedStateUseConcurrencyLevel);
        }

        static async Task Test()
        {
            Func<int, Task> step = async delay =>
            {
                await Task.Delay(delay);
                WorkWithSharedState();
                await Task.Delay(delay);
                WorkWithSharedState();
                await Task.Delay(delay);
                WorkWithSharedState();
            };
            var r = new Random();
            await Task.WhenAll(Enumerable.Range(0, 10).Select(i => step(r.Next(100))));
        }

        class MySynchronizationContext : SynchronizationContext
        {
            ConcurrentQueue<KeyValuePair<SendOrPostCallback, object>> callbacksQueue =
                new ConcurrentQueue<KeyValuePair<SendOrPostCallback, object>>();
            int workitemSubmitted;

            public override void Post(SendOrPostCallback d, object state)
            {
                callbacksQueue.Enqueue(new KeyValuePair<SendOrPostCallback, object>(d, state));
                ScheduleThreadPoolWorkItem();
            }

            void ScheduleThreadPoolWorkItem()
            {
                if (callbacksQueue.Count > 0)
                {
                    if (Interlocked.Exchange(ref workitemSubmitted, 1) == 0)
                    {
                        ThreadPool.QueueUserWorkItem(_ =>
                        {
                            SetSynchronizationContext(this);
                            for (int itemsToProcess = callbacksQueue.Count; itemsToProcess > 0; --itemsToProcess)
                            {
                                KeyValuePair<SendOrPostCallback, object> item;
                                if (callbacksQueue.TryDequeue(out item))
                                    item.Key(item.Value);
                            }
                            Debug.Assert(Interlocked.Exchange(ref workitemSubmitted, 0) == 1);
                            ScheduleThreadPoolWorkItem();
                        });
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            SynchronizationContext.SetSynchronizationContext(null);
            Console.WriteLine("Default context set");
            Test().Wait();

            Console.WriteLine("Custom context set");
            SynchronizationContext.SetSynchronizationContext(new MySynchronizationContext());
            Test().Wait();

            Console.ReadKey();
        }
    }
}

SS> if (callbacksQueue.Count > 0)
SS>

SS> for (int itemsToProcess = callbacksQueue.Count; itemsToProcess > 0; --itemsToProcess)
SS>

while (callbacksQueue.TryDequeue(out item))
{
//code
}

S>Как обычно: предлагаем что-то — не останавливаемся,а думаем "а что, если моё пожелание сбудется?". Дальше продолжать?

S>public class AsyncProducerConsumerCollection<T>
S>{
S>    private readonly Queue<T> m_collection = new Queue<T>();

S>    private readonly Queue<TaskCompletionSource<T>> m_waiting =
S>        new Queue<TaskCompletionSource<T>>();

S>    public void Add(T item)
S>    {
S>        TaskCompletionSource<T> tcs = null;
S>        lock (m_collection)
S>        {
S>            if (m_waiting.Count > 0)
S>                tcs = m_waiting.Dequeue();
S>            else
S>                m_collection.Enqueue(item);
S>        }
S>        if (tcs != null)
S>            tcs.TrySetResult(item);
S>    }

S>    public Task<T> Take()
S>    {
S>        lock (m_collection)
S>        {
S>            if (m_collection.Count > 0)
S>            {
S>                return Task.FromResult(m_collection.Dequeue());
S>            }
S>            else
S>            {
S>                var tcs = new TaskCompletionSource<T>();
S>                m_waiting.Enqueue(tcs);
S>                return tcs.Task;
S>            }
S>        }
S>    }
S>}

S>static class Program
S>{
S>    private static AsyncProducerConsumerCollection<Action> m_data = new AsyncProducerConsumerCollection<Action>();

S>    private static async Task ConsumerAsync()
S>    {
S>        while (true)
S>        {
S>            var nextItem = await m_data.Take();
S>            nextItem.Invoke();
S>        }
S>    }

S>    private static void Produce(Action data)
S>    {
S>        m_data.Add(data);
S>    }

S>    static void Main(string[] args)
S>    {
S>        var local1 = 0;
S>        Action a = null;
S>        a = () =>
S>        {
S>            while (local1 == 0)
S>            {
S>                Produce(
S>                    () =>
S>                    {
S>                        Console.WriteLine(">local1++");
S>                        local1++;
S>                        Produce(a);
S>                    });
S>            }
S>            Console.WriteLine("!!!" + local1);
S>        };

S>        Produce(a);
S>        ConsumerAsync().Wait();

S>        Console.WriteLine("Done.");
S>        Console.ReadKey();
S>    }
S>}
S>

ConsumerAsync();

Produce(a);

while (local1 == 0)
            {
// Просто запускает делегат
// А он не выполнится пока ConsumerAsync() не сработает
// А он в твоем алгоритме стоит поле Produce
// И цикл крутится бесконечно
                Produce(
                () =>
                    {
                        Console.WriteLine(">local1++");
                        local1++;
                        Produce(a);
                    });
            }

S>В общем, не надо изобретать велосипед, когда есть await. Проверено сложным способом

while (local1 == 0)
            {
// Будет крутится в цикле пока не вызовется
// Этот делегат

                Produce(
                () =>
                    {
                        Console.WriteLine(">local1++");
                        local1++;
                        Produce(a);
                    });
            }

while (true)
        {
            var nextItem = await m_data.Take();
            nextItem.Invoke(); // Будет выполняться пока очередь не вызовет OutOfMemmory
        }

event.WaitOne();
event.Set();

var nextItem = await m_data.Take();

Для тасков так делать нельзя, дедлок | забитую очередь отхватить можно
...
Но топикстартеру надо "SynchronizationContext который бы сериализовал колбэки"...
Вызывать калбэки напрямую или ч/з await тут роли не играет, проблема с самими задачами.