8

假设我们有两个工人。每个工人都有一个 id0和1。还假设我们一直有工作到达，每个工作也有一个标识符0或1指定哪个工人必须做这项工作。

我想创建 2 个最初被锁定的线程，然后当两个作业到达时，解锁它们，每个人都完成他们的工作，然后再次锁定它们，直到其他作业到达。

我有以下代码：

  #include <iostream>
  #include <thread>
  #include <mutex>

  using namespace std;

  struct job{

      thread jobThread;
      mutex jobMutex;

  };

  job jobs[2];


  void executeJob(int worker){

      while(true){

          jobs[worker].jobMutex.lock();

          //do some job

      }

   }

  void initialize(){

      int i;
      for(i=0;i<2;i++){
                jobs[i].jobThread = thread(executeJob, i);
      }

   }

  int main(void){

      //initialization
      initialize();

      int buffer[2];
      int bufferSize = 0;

      while(true){
          //jobs arrive here constantly, 
            //once the buffer becomes full, 
            //we unlock the threads(workers) and they start working
          bufferSize = 2;
          if(bufferSize == 2){
              for(int i = 0; i<2; i++){
                  jobs[i].jobMutex.unlock();
              }
          }
           break;
     }

  }

std::thread我几天前开始使用，我不知道为什么，但 Visual Studio 给我一个错误说abort() has been called. 我相信缺少一些东西，但是由于我的无知，我无法弄清楚是什么。

我希望这段代码实际上

  1. 初始化两个线程，然后锁定它们

  2. 在主函数中解锁两个线程，这两个线程将完成它们的工作（在这种情况下什么都不做），然后它们将再次被锁定。

但它给了我一个错误。我究竟做错了什么？

先感谢您！

4

3 回答 3

9

为此，您可以使用 boost 的线程池类。它高效且经过良好测试。开源库，而不是您新编写并稳定它。

http://threadpool.sourceforge.net/

main()
{
    pool tp(2);   //number of worker threads-currently its 2.

    // Add some tasks to the pool.
    tp.schedule(&first_task);
    tp.schedule(&second_task);
}

void first_task()
{
    ...
}

void second_task()
{
    ...
}

笔记：

对您的示例的建议：您不需要为每个线程都有单独的互斥对象。单个互斥对象锁本身将在所有线程之间进行同步。您在 executejob 函数中锁定了一个线程的互斥锁，而没有解锁另一个线程正在调用具有不同互斥锁对象的锁，从而导致死锁或未定义的行为。

此外，由于您在 whileloop 内调用 mutex.lock() 而没有解锁，因此同一线程正试图用同一互斥对象无限锁定自身，从而导致未定义的行为。

如果您不需要并行执行线程，您可以在 executejob 函数中使用一个全局互斥对象来锁定和解锁。

mutex m;

void executeJob(int worker)
{
    m.lock();

    //do some job

    m.unlock();
}

如果你想并行执行作业，请使用我之前建议的 boost 线程池。

于 2013-04-12T17:02:56.193 回答
9

一般来说，您可以编写类似于以下的算法。它适用于 pthreads。我确信它也适用于 c++ 线程。

  1. 创建线程并让它们等待条件变量，例如work_exists。
  2. 当工作到达时，您通知正在等待该条件变量的所有线程。然后在主线程中你开始等待另一个条件变量work_done
  3. 收到work_exists通知后，工作线程醒来，从 中获取分配的工作jobs[worker]，执行它，在变量上发送通知work_done，然后返回等待work_exists条件变量
  4. 当主线程收到work_done通知时，它会检查是否所有线程都已完成。如果没有，它会一直等待，直到最后一个完成线程的通知到达。
于 2013-04-12T18:27:57.000 回答
2

从cppreference 的页面std::mutex::unlock：

互斥锁必须被所有成功锁定它的线程解锁，然后才能被销毁。否则，行为未定义。

您让一个线程代表另一个线程解锁互斥锁的方法是不正确的。

您尝试的行为通常会使用std::condition_variable. 如果您查看成员函数的链接，就会有一些示例。

于 2013-04-12T17:00:50.063 回答