Question

我想在一个循环中创建一个线程，当创建线程时，在线程完成之前不要再次创建它。我使用下面的代码，但是它不起作用，因为互斥锁将在已解锁的情况下解锁。谁能告诉我该怎么做？

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

int counter = 0;
std::mutex mtx;
std::thread t;

void test_mutex_t2()
{
 std::lock_guard<std::mutex> lock(mtx);
 counter++;
}

void test_mutex_t1()
{
 while (1) {
   if (mtx.try_lock())
   {
     t = std::thread(test_mutex_t2);    
     mtx.unlock();
   }
 }
}

int main()
{
  test_mutex_t1();
  return 0;
}

Answer 1

std::thread必须detach或join：

std::mutex mtx;
std::thread t;

void test_mutex_t2()
{
    std::lock_guard<std::mutex> lock(mtx);
    counter++;
}

void test_mutex_t1()
{
    while (1) {
        if (mtx.try_lock())
        {
            t = std::thread(test_mutex_t2);
            t.detach();
            mtx.unlock();
        }
    }
}

Answer 2

听起来，您真正想要的是随时都只运行一个后台线程。如果是这样，我建议您完全摆脱锁，而在退出循环之前选择join()线程。像这样：

while (true) {
    auto thr = std::thread(test_mutex_t2);
    thr.join(); // Will block until thread exits
}

但是，我还要指出，这意味着您将精确地运行一个线程。这就提出了一个问题，为什么还要使用线程？您正在生成额外的线程只是为了进行同步工作。

如果确实需要多个线程，则需要一个不同的同步原语。从根本上讲，互斥锁旨在保护对单个资源的访问。您想要做的是从后台线程到主线程进行通信，并在后台线程完成某件事（在本例中为完成）时通知主线程。通常使用条件变量或信号量来完成此操作。 std::condition_variable类实现了第一个。

我建议向线程函数传递一个条件变量，该条件变量用于在完成时向主线程发出警报。像这样：

void thread_func(std::condition_variable* cv) {
     // do work
     cv->notify_one();
}

int main(void) {
     std::condition_variable cv;
     std::mutex lock;
     while (true) {
         std::unique_lock<std::mutex> lock(mut);
         auto thr = std::thread(thread_func, &cv);
         cv.wait(lock); // Wait for background thread to notify us
         thr.join();
     }
}

同样，对于这个简单的例子，这太过分了；我将使用上述的join()方法。但是，如果您希望使用更复杂的通信模式，即主线程需要在多个位置等待后台线程，则条件变量更为合适。

如何在另一个线程中创建互斥锁？

2 个答案: