Qt中的那些坑(一)---由信号引起的死锁

快来打我* 2024-04-18 20:43 1阅读 0赞

### **【写在前面】** ###

最近在用 QMutex 的时候，偶然出现了死锁。

这个场景并不常见，并且可能是自己的习惯导致。![20190911160530280.jpg][]

不过既然出现了，那么在以后编程中就需要注意。

--------------------

### **【正文开始】** ###

先直接上代码吧：

#include <QApplication>
    #include <QMutex>
    #include <QThread>
    #include <QWidget>
    
    class Test : public QWidget
    {
        Q_OBJECT
    
    public:
        Test(QWidget *parent = nullptr) : QWidget(parent) {
            connect(this, &Test::signalA, this, &Test::testB);
        }
    
        void test() {
            m_mutex.lock();
            //do something
            emit signalA();
            m_mutex.unlock();
        }
    
    public slots:
        void testB() {
            m_mutex.lock();
            //do something
            //QThread::msleep(1000);
            m_mutex.unlock();
        }
    
    signals:
        void signalA();
    
    private:
        QMutex m_mutex;
    };
    
    int main(int argc, char **argv)
    {
        QApplication a(argc, argv);
    
        Test t;
        t.show();
        t.test();
    
        return a.exec();
    }
    
    #include "main.moc"

这里要提一下，QObject::connect() 的连接类型默认是 Qt::AutoConnection ，在同一线程中即为 Qt::DirectConnection。

因此，在代码里，test() 函数实际为：

void test() {
        m_mutex.lock();
        signalA() call -> testB() {
            m_mutex.lock();
            //do something
            m_mutex.unlock();
        }
        m_mutex.unlock();
    }

可以看到，互斥锁 m\_mutex 连续锁定( lock() )了两次，而第二次锁定将导致当前线程被挂起(例子中为主线程)，**并且**，没有任何地方能够解锁( unlock() )，此时也就产生了死锁。

出现这种情况的原因还是我太习惯用信号了，实际上，如果 testB() 是另外一个线程的函数，那么 signalA() 将是以 Qt::QueueConnection 的方式连接到 testB() ，死锁就不会产生：

#include <QApplication>
    #include <QMutex>
    #include <QThread>
    #include <QDebug>
    
    class Test : public QThread
    {
        Q_OBJECT
    
    public:
        Test(QObject *parent = nullptr) : QThread(parent) {
            connect(this, &Test::signalA, this, &Test::testB);
        }
    
        void test() {
            m_mutex.lock();
            //do something
            emit signalA();
            m_mutex.unlock();
            qDebug() << QThread::currentThreadId() << " test unlock()";
        }
    
    public slots:
        void testB() {
            m_mutex.lock();
            //do something
            m_mutex.unlock();
            qDebug() << QThread::currentThreadId() << " testB unlock()";
        }
    
    signals:
        void signalA();
    
    protected:
        void run() {
            test();
        }
    
    private:
        QMutex m_mutex;
    };
    
    int main(int argc, char **argv)
    {
        QApplication a(argc, argv);
    
        Test t;
        t.start();
    
        return a.exec();
    }
    
    #include "main.moc"

testB() 在主线程，test() call signalA() 则处于 run() 函数也就是子线程中。

其运行结果如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyODMyMjY_size_16_color_FFFFFF_t_70][]

互斥锁正确的解锁了两次，即消除了死锁，当然，**这并不是正确的解决方案 ( 因为利用了 QueueConnection 进入了事件循环，只是表面上是消除了，与多线程无关 )。**

实际上，真正的解决方案相当简单：**只需将 emit signalA() 移出 \{ lock() unlock() \} 即可**。

同样，**更需要注意的是：QMutexLocker** 。

还是最开始的场景，这次使用 QMutexLocker：

#include <QApplication>
    #include <QWidget>
    #include <QMutex>
    #include <QThread>
    
    class Test : public QWidget
    {
        Q_OBJECT
    
    public:
        Test(QWidget *parent = nullptr) : QWidget(parent) {
            connect(this, &Test::signalA, this, &Test::testB);
        }
    
        void test() {
            QMutexLocker locker(&m_mutex);
            //do something
            emit signalA();
        }
    
    public slots:
        void testB() {
            QMutexLocker locker(&m_mutex);
            //do something
        }
    
    signals:
        void signalA();
    
    private:
        QMutex m_mutex;
    };
    
    int main(int argc, char **argv)
    {
        QApplication a(argc, argv);
    
        Test t;
        t.show();
        t.test();
    
        return a.exec();
    }
    
    #include "main.moc"

结果仍是产生了死锁。![20190911210524573.png][]

当然，这也是 QMutexLocker 这类 Locker 的弊端 (在析构中 unlock)，所以要谨慎啊喂(\#\`O′)。

--------------------

### **【结语】** ###

最后，一点建议：

*  QMutex 的 lock() 和 unlock() 之间尽量只包含对共享变量的读 / 写操作，不要有任何其他函数调用(除非保证不会产生死锁)。
 *  QMutexLocker，尽量自己控制作用域(看得见的析构)：**\{**      QMutextLocker(&mutex);     **\}**，在作用域结束时析构。
 *  一定，一定，一定要谨慎。![20190911214943472.jpg][]

[20190911160530280.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d16451d267084865ae948b6a54a94a3c.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyODMyMjY_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/38630634558446408655e309e9a15367.png
[20190911210524573.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ed35795b286e4d1d96cd9f2efa984721.png
[20190911214943472.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fc75377c10c447ccacdd30b693a40544.jpg