通过事件线程同步的开销

Question

我正在尝试多线程同步。对于一个背景，我有一套约100000个对象 - 可能更多 - 我想以不同的方式每秒处理多次。

现在我最关心的是同步的性能。

这是我认为应该工作得很好（我省略了所有的安全方面，因为这只是一个测试程序，如果出现错误，程序将会崩溃..）。我写了两个funktions，第一个由程序的主线程执行，第二个由所有其他线程运行。

void SharedWorker::Start() 
{ 
    while (bRunning) 
    { 
     // Send the command to start task1 
     SetEvent(hTask1Event); 

     // Do task1 (on a subset of all objects) here 

     // Wait for all workers to finish task1 
     WaitForMultipleObjects(<NumberOfWorkers>, <ListOfTask1WorkerEvents>, TRUE, INFINITE); 

     // Reset the command for task1 
     ResetEvent(hTask1Event); 

     // Send the command to start task2 
     SetEvent(hTask2Event); 

     // Do task2 (on a subset of all objects) here 

     // Wait for all workers to finish task2 
     WaitForMultipleObjects(<NumberOfWorkers>, <ListOfTask2WorkerEvents>, TRUE, INFINITE); 

     // Reset the command for task2 
     ResetEvent(hTask2Event); 

     // Send the command to do cleanup 
     SetEvent(hCleanupEvent); 

     // Do some (on a subset of all objects) cleanup 

     // Wait for all workers to finish cleanup 
     WaitForMultipleObjects(<NumberOfWorkers>, <ListOfCleanupWorkerEvents>, TRUE, INFINITE); 

     // Reset the command for cleanup 
     ResetEvent(hCleanupEvent); 
    } 
} 

DWORD WINAPI WorkerThreads(LPVOID lpParameter) 
{ 
    while (bRunning) 
    { 
     WaitForSingleObject(hTask1Event, INFINITE); 

     // Unset finished cleanup 
     ResetEvent(hCleanedUp); 

     // Do task1 (on a subset of all objects) here 

     // Signal finished task1 
     SetEvent(hTask1); 

     WaitForSingleObject(hTask2Event, INFINITE); 

     // Reset task1 event 
     ResetEvent(hTask1); 

     // Do task2 (on a subset of all objects) here 

     // Signal finished task2 
     SetEvent(hTask2); 

     WaitForSingleObject(hCleanupEvent, INFINITE); 

     // Reset update event 
     ResetEvent(hTask2); 

     // Do cleanup (on a subset of all objects) here 

     // Signal finished cleanup 
     SetEvent(hCleanedUp); 
    } 

    return 0; 
} 

要指出我的要求，我只是给你一个小例子： 说我们得到了上述10万点的对象，分成12500个对象中的每个，现代多核处理器的8子集有8个逻辑核心。相关部分是时间。所有任务必须在大约8ms内完成。

我现在的问题是，我能从分割处理中获得显着的提升，还是通过事件的同步过于昂贵？或者如果所有任务都需要这样完成，甚至有另一种方法可以用更少的努力或处理时间同步线程？

Answer 1

如果您对单个对象的处理速度很快，请不要在线程之间进行拆分。 Windows上的线程同步在每个上下文切换时都会消耗50ms以上的时间。系统不使用这段时间，而只是在系统上运行其他内容的时间。

但是，如果每个对象处理大约需要8ms，那么跨线程池就有一个工作计划点。然而，对象处理可能会有所不同，并且大量工作者线程会在不同的时刻完成工作。

更好的方法是组织一个同步的对象队列，您可以添加要处理的对象，并从中处理它们。此外，由于单个对象的处理比线程的调度间隔低很多，所以最好将它们分批处理（如10-20）。您可以估算池中工作线程的最佳数量，以及具有测试的最佳批处理大小。

所以伪代码可以是这样的：

main_thread: 
    init queue 
    start workers 

    set counter to 100000 
    add 100000 objects to queue 
    while (counter) wait(); 

worker_thread: 
    while (!done) 
     get up to 10 objects from queue 
     process objects 
     counter -= processed count 
     if (counter == 0) notify done