等待线程超时：冻结

Question

I don't understand anything now. Consider I have next piece of code (simplified version):

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <chrono>

const auto k_sleep = std::chrono::seconds{3};
const auto k_wait = std::chrono::seconds{1};
const auto k_repeats = 20u;

void test()
{
    std::mutex m;
    std::condition_variable c;
    bool processed = false;

    std::thread worker{[&]() {
            std::this_thread::sleep_for(k_sleep);

            std::unique_lock<std::mutex> lock(m);
            processed = true;
            lock.unlock();
            c.notify_one();
        }};

    std::unique_lock<std::mutex> lock(m);
    if(c.wait_for(lock, k_wait, [&processed]() {
            return processed;
        }))
    {
        worker.join();
        std::cout << "done" << std::endl;
    }
    else
    {
        worker.detach();
        std::cout << "timeout" << std::endl;
    }
}

int main()
{
    for(auto i = 0u; i < k_repeats; ++i)
        test();
}

Few questions:

• are there any deadlocks ?
• am I using condition_variable (and all other stuff relative to thread ) correctly ?
• is there UB ?
• if everything OK, how many times timeout will be printed ?

As you can see, I'm running thread and waiting for it (using condition_variable ) some time. Wait time is less then thread's executing time.

With both VC++ (Visual Studio 2015, v 19.00.23026) and g++ (v 4.8.2) I have timeout 2 times printed and then I'm stuck on worker.join() under debugger. If I will increase k_sleep to something big (relatively to k_wait with small loops count), for example, 30 seconds - everything will be fine.

So, why this happens ? If I do something incorrectly please explain me the correct way. Thanks

Answer 1

You have problems with memory management there:

1. Capturing variables by reference in lambda that passed to a new thread.
2. All variables ( m , c and processed ) are allocated on the stack, and they will go out of scope when you detach a worker thread. So, when the thread wake up, it will access garbage.

So, you need to allocate you data on the heap and make sure you do not capture variables by reference. I always prefer to pass data explicitly into std::thread .

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <chrono>
#include <memory>

const auto k_sleep = std::chrono::seconds{ 3 };
const auto k_wait = std::chrono::seconds{ 1 };
const auto k_repeats = 20u;


struct Data
{
   std::mutex m;
   std::condition_variable c;
   bool processed = false;
};

void test()
{
   auto data = std::make_shared<Data>();

   auto run = [](std::shared_ptr<Data> i_data) {
      std::this_thread::sleep_for(k_sleep);

      std::unique_lock<std::mutex> lock(i_data->m);
      i_data->processed = true;
      lock.unlock();
      i_data->c.notify_one();
   };

   std::thread worker{ run, data };

   std::unique_lock<std::mutex> lock(data->m);
   if (data->c.wait_for(lock, k_wait, [&data]() {
      return data->processed;
   }))
   {
      worker.join();
      std::cout << "done" << std::endl;
   }
   else
   {
      worker.detach();
      std::cout << "timeout" << std::endl;
   }
}

int main()
{
   for (auto i = 0u; i < k_repeats; ++i)
      test();
}