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

Question

I want to create a thread in a loop, and when the thread is created, don't create it again until the thread is done. I use the code below, but it's not working, because the mutex will unlock while it's already unlocked. Can anyone tell me how to do?

#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 have to detach or 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

It sounds like what you actually want is to have exactly one background thread running at any time. If that's true, I would suggest getting rid of the locks entirely, opting instead to join() the thread before exiting the loop. Something like this:

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

However, I'd also like to point out that this means you'll have exactly one thread running. This raises the question, why are you using threads at all? You're spawning extra threads just to do synchronous work.

If you really do want multiple threads, you need a different synchronization primitive. Fundamentally, a mutex is designed to protect access to a single resource. What you want to do is communicate from the background thread to the main thread, notifying the main thread when the background thread has done something (finished, in this case). This is usually accomplished with a condition variable or a semaphore. The std::condition_variable class implements the first of these.

I would recommend passing the thread function a condition variable, which it uses to alert the main thread when it is finished. Something like this:

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();
     }
}

Again, this is overkill for this simple example; I would use the join() method as above. But if you want have a more complicated communication pattern, where the main thread needs to wait at multiple places for the background thread, the condition variable is more appropriate.