在.Net / C＃中，当我所有的工作线程都已完成处理时，有没有办法等待或得到通知？

Question

I've got a .Net C# application where I'm attempting to spawn multiple threads. The application is for performance testing and is a simple console app. The piece for spawning threads works fine.

What I'm looking for is the correct mechanism fo either being notified when all the threads complete execution, or waiting within my application for all the threads to complete. At the point I will print out the summary of the results.

Here is what my code snippet looks like:

String testName = "foo";
String fullTestName;

// Iterate and create threads
for (int index = 0; index < numberOfThreads; index++)
{
    fullTestName = String.Format("{0}Thread{1}", testName, index);

    Thread thread = new Thread(() => PerformanceTest(fullTestName, index, numberOfRows, testToRun));

    thread.IsBackground = true;
    thread.Name = fullTestName;
    thread.Start();
}

void PerformanceTest(String testName, int iterationNumber, long numberOfRows)
{
    // Insert a bunch of rows into DB
}

I've looked at using RegisterWaitForSingleObject(), but could not figure out how to use it with my scenario.

Answer 1

You can use Task instead of Thread . It gives you higher level of abstraction over parallel operations and with that a nice library of synchronization methods. For example you can use the following to wait for all Tasks to finish.

IEnumerable<Task> BeginParallelTests(string fullTestName, int numberOfThreads)
{
    for(var index = 0; index < numberOfThreads; index++)
    {
        yield return Task.Factory.StartNew(
            () => PerformanceTest(fullTestName, index, numberOfRows));
    }
}

And then in your main method you can use just:

Task.WaitAll(BeginParallelTests(testName, numberOfThreads));

(Maybe you'll have to use something like ToArray() to force the enumeration of the the BeginParallelTest method)

Answer 2

Try using Tasks instead of threads.

class Program
{

    static Random random = new Random();

    static void Main(string[] args)
    {
        TaskFactory taskfactory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
        var tasks = new List<Task>();
        for (int i = 0; i < 10; i++)
        {
            var task = taskfactory.StartNew(() => { DoWork("Thread " + i); });
            Console.WriteLine(string.Format("Started thread {0}", i));
            tasks.Add(task);
        }
        Task.WaitAll(tasks.ToArray());  
    }

    static void DoWork(string threadname)
    {
        int sleeptime = random.Next(10) * 1000;
        Console.WriteLine(string.Format("Thread {0} sleeping {1}ms", threadname, sleeptime));
        Thread.Sleep(sleeptime);
    }
}

Answer 3

What I'm looking for is the correct mechanism fo either being notified when all the threads complete execution, or waiting within my application for all the threads to complete.

The simplest approach is just to keep track of the threads (use an array) and then call Thread.Join on each thread in turn:

Thread[] threads = new Thread[numberOfThreads];
for (int index = 0; index < numberOfThreads; index++)
{
    string fullTestName = String.Format("{0}Thread{1}", testName, index);

    Thread thread = new Thread
         (() => PerformanceTest(fullTestName, index, numberOfRows, testToRun));    
    thread.IsBackground = true;
    thread.Name = fullTestName;
    thread.Start();
    threads[index] = thread;
}

// Wait for everything to finish
foreach (Thread thread in threads)
{
    thread.Join();
}

Using the Task Parallel Library would be another alternative, but then you may well not have many threads running at a time - it may well perform better that way, but if you're trying to measure what happens with a specific number of threads, you need to really start them all yourself.

Answer 4

Another suggestion would be to step up a level of abstraction with either PLinq or the new asynch keywords.

Here is a PLinq example that abstracts threading away from the developer to the framework.

string testName = "foo";
string fullTestName;

var testIterations = 100;
Enumerable.Range(0, testIterations).AsParallel().ForAll(i=>
{
    PerformanceTest(testName,i,numberOfRows);
});


void PerformanceTest(String testName, int iterationNumber, long numberOfRows)
{
    // Insert a bunch of rows into DB
}