Question

为了学习boost :: thread的组合，我正在为线程实现一个简单的屏障（BR）来锁定一个公共的互斥锁（M）。但是，就我转到BR.wait（）而言，互斥锁上的锁定没有释放，因此为了让所有线程都到达BR，需要手动释放M上的锁定。所以我有以下代码：

boost::barrier BR(3);
boost::mutex M;

void THfoo(int m){
    cout<<"TH"<<m<<" started and attempts locking M\n";
    boost::lock_guard<boost::mutex> ownlock(M);

    cout<<"TH"<<m<<" locked mutex\n";
    Wait_(15); //simple wait for few milliseconds

    M.unlock(); //probably bad idea
    //boost::lock_guard<boost::mutex> ~ownlock(M);
    // this TH needs to unlock the mutex before going to barrier BR

    cout<<"TH"<<m<<" unlocked mutex\n";
    cout<<"TH"<<m<<" going to BR\n";
    BR.wait();
    cout<<"TH"<<m<<" let loose from BR\n";
}

int main()  
{  
    boost::thread TH1(THfoo,1);
    boost::thread TH2(THfoo,2);
    boost::thread TH3(THfoo,3);

    TH2.join(); //but TH2 might end before TH1, and so destroy BR and M
    cout<<"exiting main TH \n";

    return 0;  
}

而M.unlock（）显然是一个糟糕的解决方案（不使用锁）;那么如何（简单地）释放锁？另外：我如何（正确）在main（）中等待所有线程完成？（TH2.join（）很糟糕，因为TH2可能先完成......）;

请不要建议复飞，例如使用条件变量，我也可以使用它，但必须可以在没有条件变量的情况下直接进行。

Answer 1

除了在一个区块中确定boost::lock_guard作用域之外，您还可以使用boost::unique_lock明确显示unlock()的内容：

boost::unique_lock<boost::mutex> ownlock(M);

cout<<"TH"<<m<<" locked mutex\n";
Wait_(15); //simple wait for few milliseconds

ownlock.unlock();

如果您需要在以后重新获取互斥锁之前释放互斥锁，这将非常有用。

至于加入，只需依次在所有线程句柄上调用join()。

Answer 2

类似的东西：

void THfoo(int m){
  // use a scope here, this means that the lock_guard will be destroyed (and therefore mutex unlocked on exiting this scope
  {
    cout<<"TH"<<m<<" started and attempts locking M\n";
    boost::lock_guard<boost::mutex> ownlock(M);

    cout<<"TH"<<m<<" locked mutex\n";
    Wait_(15); //simple wait for few milliseconds

  }
  // This is outside of the lock
  cout<<"TH"<<m<<" unlocked mutex\n";
  cout<<"TH"<<m<<" going to BR\n";
  BR.wait();
  cout<<"TH"<<m<<" let loose from BR\n";
}

至于等待，只需在所有线程句柄上调用join（如果它们已经完成，函数将立即返回）

TH1.join();
TH2.join();
TH3.join();

Answer 3

让它超出范围：

void THfoo(int m){
    cout<<"TH"<<m<<" started and attempts locking M\n";
    {
       boost::lock_guard<boost::mutex> ownlock(M);

       cout<<"TH"<<m<<" locked mutex\n";
       Wait_(15); //simple wait for few milliseconds
    }

    // this TH needs to unlock the mutex before going to barrier BR

    cout<<"TH"<<m<<" unlocked mutex\n";
    cout<<"TH"<<m<<" going to BR\n";
    BR.wait();
    cout<<"TH"<<m<<" let loose from BR\n";
}

Answer 4

cout<<"TH"<<m<<" started and attempts locking M\n";
{
    boost::lock_guard<boost::mutex> ownlock(M);

    cout<<"TH"<<m<<" locked mutex\n";
    Wait_(15); //simple wait for few milliseconds

} //boost::lock_guard<boost::mutex> ~ownlock(M);
// this TH needs to unlock the mutex before going to barrier BR

cout<<"TH"<<m<<" unlocked mutex\n";

只要您join所有线程，TH2首先完成时唯一的问题是TH1必须完成运行才能在join“收集”TH2之前完成运行，以及任何剩余的资源，例如返回值已释放。 3线程并不值得担心。如果该内存使用有问题，那么您可以使用timed_join依次重复尝试所有线程。

你也可以做你不想要的事情 - 让主线程在条件变量上等待，并且每个线程在完成时在某处存储一个值来表示它已完成，并发出条件变量的信号以便主线程可以join它。你必须绝对确定线程会发出信号，否则你可能会永远等待它。如果你取消线程，请小心。

Answer 5

如果你使用boost :: mutex :: scoped_lock而不是boost :: lock_guard，它有一个unlock（）方法。如果你调用它，那么锁将不会尝试在其析构函数中重新解锁。我发现代码更符合我的口味，而不是将锁放入自己的块中。

手动释放增强锁？

5 个答案: