Multithreading 多线程：如何'；锁'；由一个或多个线程创建的对象

我有一个“主”线程，它创建类

SlowData

的对象数组。这些对象的操作速度相对较慢。这就是为什么在我最初加载它们时，它们会被存根数据填充

加载数组中的每个对象后，我可以立即在UI中显示数组。同时，我在数组上启动计算。

SlowData计算

对象被指示向UI报告结果（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
}

最后，这里是一些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
  }
};

类数据用户界面
{
std:：vector*myData；
公众：
void可视化InMessageLoop（）
{
消息aMsg；
while（HasMessage（aMsg））
如果（aMsg.Code==消息：：MSG\u程序\u退出）
SignalQuit（）；//下次，HasMessage将返回false
//从消息循环返回
}
};

问题是：如何确保销毁

SlowData

实例的安全性，以便如果十个计算线程中的任何一个当前正在处理一个对象，销毁需要等待这些计算线程中的每一个完成（要么是因为它完成了处理，要么是因为调用了

SlowDataComputation:：Stop

方法）？哪个同步原语最适合此任务

---

我用一个计算线程解决了这个问题。我使用了关键部分。但是这个解决方案不能很好地扩展到多个计算线程。

在

main

函数

的末尾，使用
类似于

  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.

for（t=0；t在
main
函数的末尾
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.

for（t=0；t