O que acontece quando se chama o destruidor de um objeto de thread que tem uma variável de condição esperando?
Estou usando umSynchronisedQueue
para se comunicar entre threads. Descobri que destruir o objeto thread quando o thread de anexação está aguardando uma variável de condição causaria a falha do programa. Isso pode ser corrigido chamandodetach()
antes da destruição do encadeamento. Mas eu estou querendo saber o que acontece exatamente quando um thread aguardando uma variável condicional foi finalizado. Existe outra maneira de usar a variável de condição para evitar isso?
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
template <typename Type> class SynchronisedQueue {
public:
void Enqueue(Type const & data) {
std::unique_lock<std::mutex> lock(mutex_);
queue_.push(data);
condition_.notify_one();
}
Type Dequeue() {
std::unique_lock<std::mutex> lock(mutex_);
while (queue_.empty())
condition_.wait(lock);
Type result = queue_.front();
queue_.pop();
return result;
}
private:
std::queue<Type> queue_;
std::mutex mutex_;
std::condition_variable condition_;
};
class Worker {
public:
Worker(SynchronisedQueue<int> * queue) : queue_(queue) {}
void operator()() {
queue_->Dequeue(); // <-- The thread waits here.
}
private:
SynchronisedQueue<int> * queue_;
};
int main() {
auto queue = new SynchronisedQueue<int>();
Worker worker(queue);
std::thread worker_thread(worker);
worker_thread.~thread(); // <-- Crashes the program.
return 0;
}