• Стоит на паузе в ожидании задачи
  
• Получает очередную задачу
  
• Получает команду на старт
  
• Выполняет вычисления
  
• Становится на паузу в ожидании следующей задачи (возврат к первому пункту списка)

• Все три потока должны начинать работу "одновременно" (это ограничение само появляется из следующего требования)
  
• Каждый поток должен дожидаться пока остальные два потока не выполнят работу
  
• Управляющий поток должен дожидаться пока все вычислительные потоки не встанут на паузу и только после этого раздавать им задачи
  
• Каждый поток должен быть создан только один раз
  
• Производительность решения очень важна!

    class Program
    {
        static AutoResetEvent mt = new AutoResetEvent(false);
        static AutoResetEvent th1 = new AutoResetEvent(false);
        static AutoResetEvent th2 = new AutoResetEvent(false);
        static AutoResetEvent th3 = new AutoResetEvent(false);

        static Thread mainThread;
        static Thread thread1;
        static Thread thread2;
        static Thread thread3;

        static void Main(string[] args)
        {
            mainThread = new Thread(MainThread);
            mainThread.IsBackground = true;

            thread1 = new Thread(Thread1);
            thread1.IsBackground = true;

            thread2 = new Thread(Thread2);
            thread2.IsBackground = true;

            thread3 = new Thread(Thread3);
            thread3.IsBackground = true;

            thread1.Start();
            thread2.Start();
            thread3.Start();
            mainThread.Start();

            Console.ReadLine();
        }

        static void MainThread()
        {
            while (true)
            {
                Console.Write("\nT ");

                if ((thread1.ThreadState & ThreadState.WaitSleepJoin) != ThreadState.WaitSleepJoin ||
                    (thread2.ThreadState & ThreadState.WaitSleepJoin) != ThreadState.WaitSleepJoin ||
                    (thread3.ThreadState & ThreadState.WaitSleepJoin) != ThreadState.WaitSleepJoin)
                {
                    mt.WaitOne();
                }

                if ((thread1.ThreadState & ThreadState.Running) == ThreadState.Running ||
                    (thread2.ThreadState & ThreadState.Running) == ThreadState.Running ||
                    (thread3.ThreadState & ThreadState.Running) == ThreadState.Running)
                {
                    th1.Set();
                    th2.Set();
                    th3.Set();
                }

                Thread.Sleep(1000);
            }
        }

        static void Thread1()
        {
            while (true)
            {
                mt.Set();
                th1.WaitOne();
                Console.Write("1");
            }
        }

        static void Thread2()
        {
            while (true)
            {
                mt.Set();
                th2.WaitOne();
                Console.Write("2");
            }
        }

        static void Thread3()
        {
            while (true)
            {
                mt.Set();
                th3.WaitOne();
                Console.Write("3");
            }
        }
    }

• Наличие большого количества экземпляров AutoResetEvent
  
• Необходимость выполнять проверку состояния потока через ThreadState

  while (true)
  {
    rwlock.AcquireWriterLock();
    раздать_задания():
    rwlock.ReleaseWriterLock();
    event.WaitOne()
  }

  while (true)
  {
    rwlock.AcquireReaderLock();
    сделать_работу();
    event.Set();
    rwlock.ReleaseReaderLock()
  }

  Barrier barrier = new Barrier(3 + 1);//3 рабочих потока плюс 1 управляющий
...
  while (true)
  {
    раздать_задания();
    barrier.SignalAndWait();//запускает рабочие потоки
    barrier.SignalAndWait();//ждет, когда рабочие потоки закончат работу
  }
...
  while (true)
  {
    barrier.SignalAndWait();//ждёт задание
    сделать_работу();
    barrier.SignalAndWait();//запускает получение нового задания
  }

что там еще у MS инновационного?
...
космические корабли с софтом на java бороздят просторы вселенной и Марса как минимум 10 лет, MS внедряет инновационные "таски" и async/await. Видимо с помощью "программистов шарепоинт"

    enum State
    {
        Idle, GetResult, Process
    }

    static volatile State state;

    static async Task<int> GetNextResult(int i)
    {
        Debug.Assert(state == State.GetResult, "Fail");
        Console.WriteLine("Geting result #{0}", i);

        var delayMs = (i % 5) * 200;
        await Task.Delay(TimeSpan.FromMilliseconds(delayMs));

        Debug.Assert(state == State.GetResult, "Fail");
        Console.WriteLine("Result #{0} ready, moving on", i);

        return i;
    }

    static async Task<int> Process(int worker, int i)
    {
        Debug.Assert(state == State.Process, "Fail");
        Console.WriteLine("Worker{0}: processing result #{1}", worker, i);

        var delayMs = (i % 7) * 150;
        await Task.Delay(TimeSpan.FromMilliseconds(delayMs));

        Debug.Assert(state == State.Process, "Fail");
        Console.WriteLine("Worker{0}: result #{1} processed", worker, i);
        return i;
    }

    static async Task Run(CancellationToken ct)
    {
        int num = 0;
        int taskCount = 3;
        while (!ct.IsCancellationRequested)
        {
            state = State.GetResult;
            var tasks = Enumerable.Range(0, taskCount).Select(i => GetNextResult(num + i));

            await Task.WhenAll(tasks);

            state = State.Process;
            tasks = Enumerable.Range(0, taskCount).Select(i => Process(i, num + i));

            await Task.WhenAll(tasks);

            state = State.Idle;
            num += taskCount;
        }
    }

    static void Main()
    {
        Console.WriteLine("Starting, any key to exit");
        var cts = new CancellationTokenSource();
        var task = Run(cts.Token);

        Console.ReadKey();

        cts.Cancel();
        task.Wait();
    }

        while (!ct.IsCancellationRequested)
        {
            state = State.GetResult;
            var tasks = Enumerable.Range(0, taskCount).Select(i => GetNextResult(num + i)); // (1)

            await Task.WhenAll(tasks);

            state = State.Process;
            tasks = Enumerable.Range(0, taskCount).Select(i => Process(i, num + i)); // (2)

            await Task.WhenAll(tasks);

            state = State.Idle;
            num += taskCount;
        }

        while (!ct.IsCancellationRequested)
        {
            state = State.GetResult;
            var tasks = Enumerable.Range(0, taskCount).Select(i => GetNextResult(num + i)).ToArray(); // (1)

            await Task.WhenAll(tasks);

            state = State.Process;
            var tasks2 = tasks.Select((t, i) => Process(i, t.Result)).ToArray(); // (2)

            await Task.WhenAll(tasks2);

            num += taskCount;
            state = State.Idle;
        }

        while (!ct.IsCancellationRequested)
        {
            state = State.GetResult;
            var resultTasks = Enumerable.Range(0, taskCount).Select(i => GetNextResult(num + i));
            var results = await Task.WhenAll(resultTasks);

            state = State.Process;
            var processingTasks = results.Select((result, ix) => Process(ix, result)).ToArray();
            await Task.WhenAll(processingTasks);

            num += taskCount;
            state = State.Idle;
        }

static class Programm
{
    static void Main()
    {
        int count = 4;
        var workers = Enumerable.Range(1, count).Select(i => (Action)(() => Console.WriteLine(i))).ToArray();

        var tcs = new TaskCompletionSource<bool>();
        int index = 0;
        do
        {
            TaskCompletionSource<bool> tcs2 = tcs;
            foreach (Action worker in workers)
            {
                Task.Run(async () =>
                {
                    worker();
                    if ((Interlocked.Increment(ref index) % count) == 0)
                    {
                        tcs = new TaskCompletionSource<bool>();
                        tcs2.SetResult(true);
                    }
                    await tcs2.Task;
                });
            }
            tcs2.Task.Wait();
            Console.WriteLine("do work, or esc for exit");
        }
        while (Console.ReadKey().Key != ConsoleKey.Escape);
    }
}