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

aParllel prgoamrmnig s i ahdr

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

    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;
        }

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

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

    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

S>        public async Task<IWorker> GetWorker()
S>        {
S>            Console.WriteLine("Worker {0} start", _name);

S>            await Task.Delay(_delay);

S>            Console.WriteLine("Worker {0} end", _name);
S>            return worker;
S>        }
S>

S>        public static Task<IWorker> Start()
S>        {
S>            return Worker(_cts.Token);
S>        }
S>

static async Task Run(CancellationToken ct)

var task = Run(cts.Token);

    interface IWorker
    {
        Task GetWorker();
    }

    class Worker: IWorker
    {
        readonly string _name;
        readonly int _delay;

        public Worker(string name, int delay)
        {
            _name = name;
            _delay = delay;

            TimeEngine.Add(this);
        }

        public Task GetWorker()
        {
            Task worker = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Worker {0} start", _name);

                Thread.Sleep(_delay);

                Console.WriteLine("Worker {0} end", _name);
            });

            return worker;
        }
    }

    class TimeEngine
    {
        static List<IWorker> _workers = new List<IWorker>();
        static CancellationTokenSource _cts = new CancellationTokenSource();

        public static void Add(IWorker worker)
        {
            _workers.Add(worker);
        }

        private static async Task Worker(CancellationToken ct)
        {
            while (!ct.IsCancellationRequested)
            {
                var tasks = Enumerable.Range(0, _workers.Count).Select(x => _workers[x].GetWorker());
                await Task.WhenAll(tasks);
                Console.WriteLine();
            }
        }

        public static void Start()
        {
            Worker(_cts.Token);
        }

        public static void Stop()
        {
            _cts.Cancel();
        }
    }

    class Program
    {
        readonly static int _taskCount = 10;
        readonly static Random _rnd = new Random();

        static void Main(string[] args)
        {
            for (int i = 0; i < _taskCount; i++)
            {
                new Worker(i.ToString(), _rnd.Next(500, 1500));
            }

            Console.WriteLine("TimeEngine start (Press any key to Stop)");
            TimeEngine.Start();

            Console.ReadKey();

            TimeEngine.Stop();
            Console.WriteLine("TimeEngine Stop");

            Console.ReadKey();
        }
    }

static async Task Run(CancellationToken ct)

C>... но при этом в самом методе Run нет ни одного return Так и должно быть?

TimeEngine.Add(this);

    static void Do(A a) { a.DoSmth(); }

    class A
    {
        public A()
        {
            Do(this);
        }

        public virtual void DoSmth()
        {
        }
    }
    class B : A 
    {
        private readonly string message;

        public B()
        {
            this.message = "Hello";
        }
        public override void DoSmth()
        {
            base.DoSmth();

            Console.WriteLine("Message: {0}, length: {1}", message, message.Length);
        }
    }

    public static void Main(string[] args)
    {
        var x = new B();
        Console.WriteLine("{0,5}",2);
    }

            for (int i = 0; i < _taskCount; i++)
            {
                TimeEngine.Run(new Worker(i.ToString(), _rnd.Next(500, 1500));
            }

C>Да почему блин

        public async Task GetWorker()
        {
            var task = Task.Run(() =>    // (1)
            {
                Console.WriteLine("Worker {0} start", _name);

                Thread.Sleep(_delay);       // Это только для демонстрации того как превратить синхронный код в асинхронный!

                Console.WriteLine("Worker {0} end", _name);
            });

            await task;                // (2)
        }

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

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

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);
    }
}

    class Program
    {
        static readonly int counterValue = 1000000;
        static readonly int taskCount = 30000;

        static void Main(string[] args)
        {
            List<Action> actions = new List<Action>();

            for (int i = 0; i < taskCount; i++)
            {
                actions.Add(new Action(Work));
            }

            Console.WriteLine("Task speed test");

            DateTime start = DateTime.Now;

            Parallel.Invoke(actions.ToArray());

            DateTime stop = DateTime.Now;

            Console.WriteLine("Time is: {0} secs", (stop - start).TotalSeconds);
            Console.ReadLine();
        }

        public static void Work()
        {
            int counter = counterValue;

            while (true)
            {
                counter--;
                if (counter <= 0)
                    return;
            }
        }
    }

1. Каким образом удалось достигнуть такой производительности?
   
2. Стоит ли надеяться, что можно достигнуть большей производительности другим способом?
   
3. Интересно что если менять параметры counterValue и taskCount увеличивая в 10 раз один и в 10 раз уменьшая другой (или наоборот), то время выполнения задач практически не меняется. На моей машине всегда примерно 9 секунд. Складывается впечатление, что создается ограниченное количество потоков которым потом по очереди скармливаются задачи. В общем как это работает?

int counter = counterValue;
while (true)
{
        counter--;
        if (counter <= 0)
                return;
}

  [TestClass]
  public class ParallelRunUnitTest {
    public TestContext TestContext { get; set; }

    const int _actionsCount = 100;
    const int _threadsCount = 3;
    int _doneCount;
    readonly Queue<Action> _actions = new Queue<Action>(_actionsCount);
    bool _active;

    [TestMethod]
    public void UsingThreadsAndMonitorTest() {
      _doneCount = 0;
      _active = true;
      var threadList = new List<Thread>(_threadsCount);
      for (int i = 0; i < _threadsCount; i++) {
        var thread = new Thread(ThreadMethod) { IsBackground = true };
        threadList.Add(thread);
        thread.Start();
      }

      var sw = Stopwatch.StartNew();

      lock (_actions)
        for (int i = _actionsCount; i > 0;) {
          Monitor.Wait(_actions, 5);
          if (_actionsCount - i == _doneCount) {
            for (int k = Math.Min(_threadsCount, i); k > 0; k--, i--)
              _actions.Enqueue(TaskMethod);
            //Debug.WriteLine("    Add new tasks. Count: " + _actions.Count);
          }
          Monitor.Pulse(_actions);
        }

      // Подождать окончания расчета
      lock (_actions)
        while (_doneCount < _actionsCount)
          Monitor.Wait(_actions, 5);

      sw.Stop();

      // Подождать остановки потоков
      _active = false;
      foreach (var thread in threadList)
        thread.Join();

      Debug.WriteLine("  RunCount: {0}   Elapsed: {1}", _doneCount, sw.Elapsed);
    }

    void ThreadMethod() {
      while (_active) {
        Action action;
        lock (_actions) {
          while (_actions.Count == 0)
            if (_active)
              Monitor.Wait(_actions, 200);
            else
              return;
          action = _actions.Dequeue();
          Monitor.Pulse(_actions);
        }
        action();
      }
    }

    void TaskMethod() {
      const int count = 500000;
      for (int j = 0; j < 2; j++) 
      for (int i = 0; i < count; i++) {
        var a = Math.Sin(2*Math.PI*i/count);
      }
      Interlocked.Increment(ref _doneCount);
      //Debug.WriteLine("    Task done");
    }

    [TestMethod]
    public void UsingTasksTest() {
      _doneCount = 0;
      var tasks = new List<Task>(_threadsCount);
      var sw = Stopwatch.StartNew();

      for (int i = _actionsCount; i > 0;) {
        for (int k = Math.Min(_threadsCount, i); k > 0; k--, i--) {
          var task = new Task(TaskMethod);
          tasks.Add( task );
          task.Start();
        }
        //Debug.WriteLine("    Add new tasks. Count: " + tasks.Count);
        Task.WaitAll(tasks.ToArray());
        tasks.Clear();
      }

      sw.Stop();
      Debug.WriteLine("  RunCount: {0}   Elapsed: {1}", _doneCount, sw.Elapsed);
    }
  }

    interface IWorker
    {
        Task GetWorker();
    }

    class Worker: IWorker
    {
        readonly string _name;
        readonly int _delay;

        public Worker(string name, int delay)
        {
            _name = name;
            _delay = delay;

            TimeEngine.Add(this);
        }

        public Task GetWorker()
        {
            Task worker = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Worker {0} start", _name);

                Task.Delay(_delay);

                Console.WriteLine("Worker {0} end", _name);
            });

            return worker;
        }
    }

    class TimeEngine
    {
        static List<IWorker> _workers = new List<IWorker>();
        static CancellationTokenSource _cts = new CancellationTokenSource();

        public static void Add(IWorker worker)
        {
            _workers.Add(worker);
        }

        private static Task Print(int x)
        {
            Console.WriteLine(x);
            return new Task(() => { });
        }

        private static async Task Worker(CancellationToken ct)
        {
            while (!ct.IsCancellationRequested)
            {
                var tasks = Enumerable.Range(0, _workers.Count).Select(x => _workers[x].GetWorker());
                await Task.WhenAll(tasks);
                await Task.Delay(TimeSpan.FromSeconds(1));
            }
        }

        public static void Start()
        {
            Worker(_cts.Token);
        }

        public static void Stop()
        {
            _cts.Cancel();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Worker worker1 = new Worker("1", 1000);
            Worker worker2 = new Worker("2", 500);
            Worker worker3 = new Worker("3", 1200);

            Console.WriteLine("TimeEngine start (Press any key to Stop)");
            TimeEngine.Start();

            Console.ReadLine();

            TimeEngine.Stop();
            Console.WriteLine("Time Engine Stop");

            Console.ReadLine();
        }
    }

        public async Task<IWorker> GetWorker()
        {
            Console.WriteLine("Worker {0} start", _name);

            await Task.Delay(_delay);

            Console.WriteLine("Worker {0} end", _name);
            return worker;
        }

        public static Task<IWorker> Start()
        {
            return Worker(_cts.Token);
        }

        public async Task GetWorker()
        {
            await Task.Run(() =>
            {
                Console.WriteLine("Worker {0} start", _name);

                Thread.Sleep(_delay);       // Это только для демонстрации того как превратить синхронный код в асинхронный!

                Console.WriteLine("Worker {0} end", _name);
            });
        }