Question

给出以下代码：

#include <chrono>
#include <ctime>
#include <functional>
#include <iostream>
#include <thread>
#include <utility>

#include <QFuture>
#include <QMutex>
#include <QWaitCondition>
#include <QtConcurrent>

class Async
{
public:
    Async() = default;
    Async(const Async&) = delete;
    Async(Async&&) = delete;

    ~Async() = default; //{ m_mutex.unlock(); }

    Async& operator=(const Async&) = delete;
    Async& operator=(Async&&) = delete;

    template<typename t_result>
    QFuture<bool> operator()(
          std::function<t_result()>&& p_function,
          std::chrono::milliseconds p_timeout,
          t_result* p_result)
    {
        QtConcurrent::run([this, p_function, p_result]() {
            *p_result = p_function();
            std::cout << time(nullptr) << " waking" << std::endl;
            m_cond.wakeAll();
    });

    return QtConcurrent::run([this, p_timeout]() {
           std::cout << time(nullptr) << " starting to wait for "
                     << p_timeout.count() << " ms" << std::endl;
           m_mutex.lock();
           bool wait =
               m_cond.wait(&m_mutex, 
                           static_cast<unsigned 
                                       long>(p_timeout.count()));
           std::cout << time(nullptr)
                     << ", finished waiting = " 
                     << (wait ? "T" : "F") 
                     << std::endl;
           if (wait) {
               return false;
           }
           return true;
    });
  }

private:
    QMutex m_mutex;
    QWaitCondition m_cond;
};

int main()
{
  Async async;

  char letter = 'z';

  std::function<char()> f1 = []() -> char {
      std::this_thread::sleep_for(std::chrono::seconds(4));
      return 'a';
  };

  std::cout << "1: " << time(nullptr) << std::endl;
  QFuture<bool> result =
    async(std::move(f1), std::chrono::milliseconds(3999), 
          &letter);

  std::cout << "2: " << time(nullptr) << std::endl;

  std::this_thread::sleep_for(std::chrono::seconds(8));

  std::cout << "3: " << time(nullptr) << std::endl;

  if (result.result()) {
    std::cout << "timeout, letter = " << letter;
  } else {
    std::cout << "NO timeout, letter = " << letter;
  }
  std::cout << std::endl;

  return 0;
}

最后 ... 8），当我运行它时，所有cout都会打印出预期的内容，但是在执行结束时得到一个QMutex: destroying locked mutex。由于我收到消息finished waiting，m_cond.wait被执行，因此（我认为），m_mutex将被解锁。但事实并非如此。

如果我使用~Async() { m_mutex.unlock(); }，则不会收到该消息，但我认为不应该这样处理。

任何人都可以解释为什么互斥量没有被释放吗？

非常感谢！

Answer 1

当使用独占互斥锁对条件变量进行可运行的等待时，等待结束时（无论是否超时），它将在互斥锁上保持锁定。

这意味着您必须显式解锁互斥锁

bool wait = m_cond.wait(&m_mutex,static_cast<unsigned long>(p_timeout.count()));
m_mutex.unlock();
if (wait) {
    return false;
}
return true;

Answer 2

从Qt QMutex页面：

警告：销毁锁定的互斥锁可能导致不确定的行为。

抱歉，太简洁了；我在手机上输入

QMutex：销毁锁定的互斥锁

2 个答案: