让许多工作线程等待主线程的最佳方法，反之亦然

Question

I'm looking for a fast way to let many worker threads wait for an event to continue and block the main thread until all worker threads are finished. I first used TPL or AutoResetEvent but since my calculation isn't that expensive the overhead was way too much.

I found a pretty interesting article concerning this problem and got great results (using only one worker thread) with the last synchronization solution (Interlocked.CompareExchange). But I don't know how to utilize it for a scenario where many threads wait for one main tread repeatedly.

Here is an example using single thread, CompareExchange, and Barrier:

static void Main(string[] args)
{
    int cnt = 1000000;

    var stopwatch = new Stopwatch();

    stopwatch.Start();
    for (int i = 0; i < cnt; i++) { }
    Console.WriteLine($"Single thread: {stopwatch.Elapsed.TotalSeconds}s");

    var run = true;
    Task task;

    stopwatch.Restart();
    int interlock = 0;
    task = Task.Run(() =>
    {
        while (run)
        {
            while (Interlocked.CompareExchange(ref interlock, 0, 1) != 1) { Thread.Sleep(0); }
            interlock = 2;
        }
        Console.WriteLine($"CompareExchange synced: {stopwatch.Elapsed.TotalSeconds}s");
    });

    for (int i = 0; i < cnt; i++)
    {
        interlock = 1;
        while (Interlocked.CompareExchange(ref interlock, 0, 2) != 2) { Thread.Sleep(0); }
    }
    run = false;
    interlock = 1;
    task.Wait();

    run = true;
    var barrier = new Barrier(2);
    stopwatch.Restart();
    task = Task.Run(() =>
      {
          while (run) { barrier.SignalAndWait(); }
          Console.WriteLine($"Barrier synced: {stopwatch.Elapsed.TotalSeconds}s");
      });

    for (int i = 0; i < cnt; i++) { barrier.SignalAndWait(); }
    Thread.Sleep(0);
    run = false;
    if (barrier.ParticipantsRemaining == 1) { barrier.SignalAndWait(); }
    task.Wait();

    Console.ReadKey();
}

Average results (in seconds) are:

Single thread: 0,002 CompareExchange: 0,4 Barrier: 1,7

As you can see Barriers' overhead seems to be arround 4 times higher! If someone can rebuild me the CompareExchange-scenario to work with multiple worker threads this would surely help, too!

Sure, 1 second overhead for a million calculations is pretty less! Actually it just interests me.

Edit:

System.Threading.Barrier seems to be the fastest solution for this scenario. For saving a double blocking (all workers ready for work, all workes finished) I used the following code for the best results:

while(work)
{
    while (barrier.ParticipantsRemaining > 1) { Thread.Sleep(0); }
    //Set work package
    barrier.SignalAndWait()
}

Answer 1

It seems like you might want to use a Barrier to synchronise a number of workers with a main thread.

Here's a compilable example. Have a play with it, paying attention to when the output tells you that you can "Press <Return> to signal the workers to start".

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace Demo
{
    static class Program
    {
        static void Main()
        {
            print("Main thread is starting the workers.");
            int numWorkers = 10;

            var barrier = new Barrier(numWorkers + 1); // Workers + main (controlling) thread.

            for (int i = 0; i < numWorkers; ++i)
            {
                int n = i; // Prevent modified closure.
                Task.Run(() => worker(barrier, n));
            }

            while (true)
            {
                print("***************** Press <RETURN> to signal the workers to start");
                Console.ReadLine();

                print("Main thread is signalling all the workers to start.");

                // This will wait for all the workers to issue their call to
                // barrier.SignalAndWait() before it returns:

                barrier.SignalAndWait(); 

                // At this point, all workers AND the main thread are at the same point.
            }
        }

        static void worker(Barrier barrier, int workerNumber)
        {
            int iter = 0;

            while (true)
            {
                print($"Worker {workerNumber} on iteration {iter} is waiting for barrier.");

                // This will wait for all the other workers AND the main thread 
                // to issue their call to barrier.SignalAndWait() before it returns:

                barrier.SignalAndWait();

                // At this point, all workers AND the main thread are at the same point.

                int delay = randomDelayMilliseconds();
                print($"Worker {workerNumber} got barrier, now sleeping for {delay}");
                Thread.Sleep(delay);

                print($"Worker {workerNumber} finished work for iteration {iter}.");
            }
        }

        static void print(string message)
        {
            Console.WriteLine($"[{sw.ElapsedMilliseconds:00000}] {message}");
        }

        static int randomDelayMilliseconds()
        {
            lock (rng)
            {
                return rng.Next(10000) + 5000;
            }
        }

        static Random    rng = new Random();
        static Stopwatch sw  = Stopwatch.StartNew();
    }
}