Ich benutze eineSynchronisedQueue zwischen Threads kommunizieren. Ich fand, dass das Zerstören des Thread-Objekts, wenn der anhängende Thread auf eine Bedingungsvariable wartet, den Programmabsturz verursachen würde. Dies kann durch einen Anruf korrigiert werdendetach() vor der Fadenzerstörung. Aber ich frage mich, was genau passiert, wenn ein Thread, der auf eine bedingte Variable wartet, beendet wird. Gibt es eine andere Möglichkeit, die Bedingungsvariable zu verwenden, um dies zu vermeiden?

#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;
}