Question

我有一个'main'线程，它创建了一个类SlowData的对象数组。使用这些对象的操作相对较慢。这就是为什么当我最初加载它们时，它们充满了存根数据。

在加载数组中的每个对象之后，我可以在UI中显示该数组。与此并行，我开始对数组进行计算。指示SlowDataComputation对象向UI报告结果（进而可视化对特定SlowData对象的修改。）

这是看起来的样子：

void main()
{
  std::vector<SlowData> aData;
  aData.reserve(1000000); // one million instances

  Fast_PopulateVector(aData);

  DataUi aUi;

  SlowDataComputation aCalc;
  aCalc.SetUiCallback(aUi);           // instruct the object to periodically
                                      // report computation results to the UI

  aCalc.Slow_ComputeInSeveralThreads(aData);

  aUi.VisualizeInMessageLoop(aData);  // message loop that exits upon user signal

  if ( aCalc.StillWorking() )
    aCalc.Stop();                     // terminate threads gradually

  // after VisualizeInMessageLoop returns, aData will then be destroyed
}

我希望SlowDataComputation启动几个线程，每个线程都会处理数组中的某个段：

class SlowDataComputation
{
  std::vector<SlowData> * myData;
  DataUi                * myUI;

public:
  void Slow_ComputeInSeveralThreads(std::vector<SlowData> & theV)
  {
    myData = &theV;

    size_t aSize = myData->size();
    size_t aNumThreads = 10;
    size_t aBlockSize = aSize / aNumThreads;

    for (size_ti = 0; i < aNumThreads; i++)
    {
      ComputationThread aThr(myData);
      aThr.SetBoundary(i * aBlockSize, (i+1) * aBlockSize);
      aThr.SetUiCallback(myUI);

      aThr.Run();   // process a given segment in the array
    }
  }
};

最后，这里是UI的一些伪代码：

class DataUi
{
  std::vector<SlowData> * myData;

public:
  void VisualizeInMessageLoop()
  {
    Message aMsg;

    while ( HasMessage(aMsg) )
      if (aMsg.Code == Message::MSG_PROGRAM_QUIT)
        SignalQuit();  // next time, HasMessage will return false

    // return from message loop
  }
};

问题是：如何保护SlowData个实例的销毁，以便当十个计算线程中的任何一个当前正在使用对象时，破坏需要等到每个计算线程完成（因为它完成处理或因为调用了SlowDataComputation::Stop方法）？什么同步原语最适合此任务？

我设法用一个计算线程来解决这个问题。我使用了Critical Sections。但是这个解决方案不适合多个计算线程。

Answer 1

main函数join结束pthread_join所有帖子有点像...

  for(t=0; t<NUM_THREADS; t++) {
     rc = pthread_join(thread[t], &status);
     //check rc and status
  }
  //destroy shared data safely. All the threads are done.

你不需要锁定对象，这是更昂贵的。您只需要知道所有线程都完成了计算。

多线程：如何通过一个或多个线程“锁定”对象

1 个答案: