本文介绍: 今天简直是令人心力交瘁的一天,在公司一个顽固的Bug纠缠了整整一天。一开始,我对这个问题认知并不深刻,只是觉得有点小瑕疵,于是比较轻松地着手解决。我开始摸索着定位问题,态度上也没太在意,毕竟在我看来,这只是一场小小的技术挑战。然而,随着时间的推移,我逐渐意识到问题的严重性。逐渐加深的烦躁和困扰让我开始感到不安。在一度对问题轻描淡写的态度下,我终于被迫正视这个Bug所可能引发的连锁反应。随着这个问题的逐渐显露出其庞大的影响,我仿佛看到一个漩涡,正在悄然蔓延着,威胁着整个系统的稳定性。

头图

Qt_一个单例引发的崩溃

关键字
Qt
Q_GLOBAL_STATIC
单例
UI
崩溃

摘要

今天简直是令人心力交瘁的一天,在公司一个顽固的Bug纠缠了整整一天。一开始,我对这个问题认知并不深刻,只是觉得有点小瑕疵,于是比较轻松地着手解决。我开始摸索着定位问题,态度上也没太在意,毕竟在我看来,这只是一场小小的技术挑战。

然而,随着时间的推移,我逐渐意识到问题的严重性。逐渐加深的烦躁和困扰让我开始感到不安。在一度对问题轻描淡写的态度下,我终于被迫正视这个Bug所可能引发的连锁反应。随着这个问题的逐渐显露出其庞大的影响,我仿佛看到了一个漩涡,正在悄然蔓延着,威胁着整个系统的稳定性。

随着深入的调查和排查,我开始逐渐理解这个Bug的神秘本质,而这个认识过程伴随着我的焦虑逐渐升温。我发现这并非是一个简单技术故障,而是一个可能牵动公司正常运营的重大问题。这时,我终于感受到了来自责任的重压,因为解决这个问题不仅关乎我的个人技术能力,更涉及到公司业务持续稳健。

最终,当我对问题的了解达到顶峰时,我不禁意识到这一天的崩溃并非仅限于我的个人情绪,更是对整个系统运行稳定性的一次极大考验。这场对抗Bug的战斗让我感受到了技术领域的不可预测性和挑战性,也让我更加深刻地明白在这个领域中的学无止境。

image-20231127214955902

关于 Q_GLOBAL_STATIC

我在创建单例上偷了懒,使用了Qt Q_GLOBAL_STATIC宏来创建单例。关于Q_GLOBAL_STATIC解释如下

Q_GLOBAL_STATIC 是 Qt 框架用于创建全局静态变量的宏。这个宏的目的是确保在多线程环境安全初始化访问静态变量。在 C++ 中,全局静态变量初始化顺序可能会带来一些问题,特别是在多线程环境下。

使用 Q_GLOBAL_STATIC 宏,Qt 提供了一种线程安全机制创建全局静态变量。这个宏可以确保静态变量只在第一次访问时被初始化,而且在初始化过程中是线程安全的。

具体用法如下

Q_GLOBAL_STATIC(Type, variable)

其中,Type 是要创建静态变量的类型variable 是变量的名称

举例说明

#include <QGlobalStatic>

class MyClass {
public:
    MyClass() {
        // 构造函数
    }

    // 其他成员函数数据成员
};

Q_GLOBAL_STATIC(MyClass, myGlobalInstance)

在上面的例子中,myGlobalInstance 就是一个全局静态变量,它的类型MyClass使用 Q_GLOBAL_STATIC 宏,Qt 会在需要时确保 myGlobalInstance安全初始化,并在整个程序运行期间保持其存在

这种机制的好处是,在多线程环境下,多个线程可以同时访问 myGlobalInstance,而不必担心因为初始化顺序而导致的问题。Qt 在内部使用了一些技巧比如使用双重检查锁定(doublechecked locking)等,以确保在多线程环境下的性能正确性。

代码测试

所以,按照上面的解释,我使用Q_GLOBAL_STATIC创建一个单例,应该没有问题的。但是。

下面看下的Demo 代码

头文件

#ifndef FORM_H
#define FORM_H

#include <QWidget>

namespace Ui {
class Form;
}

class Form : public QWidget
{
    Q_OBJECT

public:
    explicit Form(QWidget *parent = nullptr);
    static Form* getInstance();
    ~Form();

private:
    Ui::Form *ui;
};

#endif // FORM_H

源文件

#include "form.h"
#include "ui_form.h"
Q_GLOBAL_STATIC(Form,m_Form)
Form::Form(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Form)
{
    ui->setupUi(this);
}

Form *Form::getInstance()
{
    return m_Form;
}

Form::~Form()
{
    delete ui;
}

调用文件

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "form.h"
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    ui->verticalLayout->addWidget(Form::getInstance());

}

MainWindow::~MainWindow()
{
    delete ui;
}


布局管理器源码分析

看到这里知道发现问题所在没有呢。其实到这里程序运行什么都都是没有问题的,就是不要退出程序,因为一旦退出程序,就会遇到崩溃问题。那么开始我一度以为是使用布局管理器导致的这个问题,但是我看了源码也却突然发现布局管理器是不会对其管理控件进行资源释放的,部分源码如下,我这里合并显示了。

QBoxLayoutPrivate::~QBoxLayoutPrivate()
{
}

/*!
    Destroys this box layout.

    The layout's widgets aren't destroyed.
*/
QHBoxLayout::~QHBoxLayout()
{
}

/*!
    

    The layout's widgets aren't destroyed.
*/
QVBoxLayout::~QVBoxLayout()
{
}

Demo 验证

保险起见,我还特意谷歌翻译了一下Destroys this box layout.The layout's widgets aren't destroyed.里面明确说明,布局会破坏,但是里面控件不会释放。所谓问题来,到底是哪里的问题了,我尝试了另一种写法代码如下,希望你还可以跟得上

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "form.h"
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    Form * temp = Form::getInstance();

    temp->setParent(this);

    temp->show();
}

MainWindow::~MainWindow()
{
    delete ui;
}

这样我得到的结果同样是崩溃的析构函数,如下图所示

image-20231127223544817

关于布局管理器析构

正当我一头雾水的手,我随机搜了一下Qt 布局管理器在析构是会析构子控件这个问题,得到的回答如下

在 Qt 中,布局管理器在析构时通常不会主动析构其管理的子控件。布局管理负责管理控件的位置大小,而控件的生命周期管理通常是由其父控件负责的。

当一个 QWidget 对象(可能是窗口或其他容器控件)被析构时,它会负责删除其子控件。这是因为 QWidget 继承自 QObject,而 QObject 有一个父子对象关系系统负责自动管理子对象内存

布局管理器在 Qt 中主要用于确定子控件的布局,而不是控制它们的生命周期。因此,当布局管理器本身被析构时,它不会主动销毁其管理的子控件。子控件的析构通常是由其父控件来处理

如果你希望在删除布局管理器的同时也删除其管理的子控件,你需要手动迭代子控件并将其删除,或者使用智能指针工具来管理控件的生命周期。这可以确保在删除布局管理器时,相关的子控件也会被正确地释放。

总的来说,Qt 的布局管理器并不负责子控件的析构,而是留给控件的父对象来管理。

结合上面对布局管理器源码的分析可以看到,我们崩溃不是有布局管理器引起的,而是被父类析构析构了。

Qt 类声明周期探索

本着刨根问题的原则,我有问了另一个问题设置了布局管理器就等于设置父类

在 Qt 中,设置了布局管理器并不等同于设置了父类。虽然布局管理器通常是作为容器控件的子对象来管理的,但它们在概念上是不同的。

  1. 父子关系

  2. 布局管理器的作用:

    • 布局管理器是用来管理布局的工具。它们通常被设置在容器类控件上,比如 QWidget、QMainWindow、QDialog 等。布局管理器负责决定子控件的排列方式,但不负责管理它们的析构。

下面是一个简单的例子,演示如何在 QWidget 中使用布局管理器:

#include <QHBoxLayout>
#include <QPushButton>
#include <QWidget>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    QWidget *mainWidget = new QWidget;
    QHBoxLayout *layout = new QHBoxLayout(mainWidget);

    QPushButton *button1 = new QPushButton("Button 1");
    QPushButton *button2 = new QPushButton("Button 2");

    layout->addWidget(button1);
    layout->addWidget(button2);

    mainWidget->setLayout(layout);
    mainWidget->show();

    return app.exec();
}

在这个例子中,mainWidget 是一个 QWidget,而 layout 是一个 QHBoxLayout。布局管理器 layout 被设置为 mainWidget 的布局管理器。然而,mainWidget 仍然是这两个按钮的父控件,而不是布局管理器。

总的来说,在设置布局管理器时,确保理解父子关系的变化,并注意生命周期管理的责任

更新代码获取父类

虽然回答的不是那么一回事,但是还是启发了,所以我对我的代码做了一点更新,如下:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "form.h"
#include <QDebug>
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    Form * temp = Form::getInstance();



    ui->verticalLayout->addWidget(temp);

    qDebug()<< "temp->parent()->" << temp->parent() << endl
             << "temp->parent()->parent()->" << temp->parent()->parent() << endl
             << "this->"<< this << endl
             << "this->parent()->" <<this->parent() << endl
             << "ui->verticalLayout->parent()" << ui->verticalLayout->parent();
}

MainWindow::~MainWindow()
{
    delete ui;
}


得到打印信息如下

temp->parent()-> QWidget(0x948920, name = "centralwidget") 
temp->parent()->parent()-> MainWindow(0x8ffd20, name = "MainWindow") 
this-> MainWindow(0x8ffd20, name="MainWindow") 
this->parent()-> QObject(0x0) 
ui->verticalLayout->parent() QWidget(0x948920, name = "centralwidget")

这下基本明白了,其实对象声明周期在Qt里面还是受气父控件的控制,而并非是布局管理器,今天我之所碰巧解决了这个Bug,仅仅是因为当我们吧控件添加到布局管理器时。不管理器把他的费空间做了传递、现在终于明白了。

分析Qt 单例宏源码

那么还需要解决另一个问题,就是我的单例宏做了什么

#define Q_GLOBAL_STATIC(TYPE, NAME)                                         
    Q_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ())
#define Q_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ARGS)                         
    namespace { namespace Q_QGS_ ## NAME {                                  
        typedef TYPE Type;                                                  
        QBasicAtomicInt guard = Q_BASIC_ATOMIC_INITIALIZER(QtGlobalStatic::Uninitialized); 
        Q_GLOBAL_STATIC_INTERNAL(ARGS)                                      
    } }                                                                     
    static QGlobalStatic<TYPE,                                              
                         Q_QGS_ ## NAME::innerFunction,                     
                         Q_QGS_ ## NAME::guard> NAME;

#if defined(Q_COMPILER_CONSTEXPR)
#  define Q_BASIC_ATOMIC_INITIALIZER(a)     { a }
#else
#  define Q_BASIC_ATOMIC_INITIALIZER(a)     { ATOMIC_VAR_INIT(a) }
#endif

#define Q_GLOBAL_STATIC_INTERNAL(ARGS)                          
    Q_GLOBAL_STATIC_INTERNAL_DECORATION Type *innerFunction()   
    {                                                           
        struct HolderBase {                                     
            ~HolderBase() noexcept                        
            { if (guard.loadRelaxed() == QtGlobalStatic::Initialized)  
                  guard.storeRelaxed(QtGlobalStatic::Destroyed); }     
        };                                                      
        static struct Holder : public HolderBase {              
            Type value;                                         
            Holder()                                            
                noexcept(noexcept(Type ARGS))       
                : value ARGS                                    
            { guard.storeRelaxed(QtGlobalStatic::Initialized); }       
        } holder;                                               
        return &amp;holder.value;                                   
    }
#else
// We don't know if this compiler supports thread-safe global statics
// so use our own locked implementation

QT_END_NAMESPACE
#include <QtCore/qmutex.h>
#include <mutex>
QT_BEGIN_NAMESPACE

#define Q_GLOBAL_STATIC_INTERNAL(ARGS)                                  
    Q_DECL_HIDDEN inline Type *innerFunction()                          
    {                                                                   
        static Type *d;                                                 
        static QBasicMutex mutex;                                       
        int x = guard.loadAcquire();                                    
        if (Q_UNLIKELY(x >= QtGlobalStatic::Uninitialized)) {           
            const std::lock_guard<QBasicMutex> locker(mutex);           
            if (guard.loadRelaxed() == QtGlobalStatic::Uninitialized) {        
                d = new Type ARGS;                                      
                static struct Cleanup {                                 
                    ~Cleanup() {                                        
                        delete d;                                       
                        guard.storeRelaxed(QtGlobalStatic::Destroyed);         
                    }                                                   
                } cleanup;                                              
                guard.storeRelease(QtGlobalStatic::Initialized);        
            }                                                           
        }                                                               
        return d;                                                       
    }
#endif

我们稍作翻译

这段宏定义了一个模板化的全局静态变量创建机制通过 Q_GLOBAL_STATIC_INTERNAL可以方便地创建一个全局静态变量。这个机制使用了 C++11 的特性,包括 noexcept 说明符和内存模型的一些操作

我们逐步解释这个宏的各个部分

  1. Q_GLOBAL_STATIC_INTERNAL(ARGS): 这是主要的宏定义,用于创建全局静态变量。ARGS传递给 Type 类型构造函数参数

  2. Q_GLOBAL_STATIC_INTERNAL_DECORATION: 这是一个在宏中使用的修饰符,可能是空的,取决于编译器对 C++11 特性支持情况。

  3. Type *innerFunction(): 这是一个内部的静态函数,负责实际创建和返回全局静态变量的指针。它使用了一个内部的 Holder 类,以确保在全局静态变量的析构期间正确地管理生命周期

  4. struct HolderBase: 这是一个基础结构,其中的析构函数负责在全局静态变量被销毁时,检查更新一个状态标志。这个标志在构造时被设置为 Initialized,而在析构时被设置为 Destroyed。

  5. struct Holder : public HolderBase: 这是一个派生自 HolderBase 的结构。它包含了具体的 Type 类型实例value),并在构造函数中将状态标志设置为 Initialized。这确保在全局静态变量的生命周期内,HolderBase 的析构函数将被正确调用,以更新状态标志。

整个机制的目的是确保在多线程环境下,全局静态变量的创建是线程安全的。通过在 HolderBase 的析构函数中检查状态标志,可以防止在全局静态变量析构时重复析构。

这是一个比较复杂实现,主要是为了保证全局静态变量的正确创建和销毁,并且在多线程环境下能够安全使用。

所以现在应该明白了,这就是资源双重释放了,未来的你,加油。


博客签名2021

原文地址:https://blog.csdn.net/z609932088/article/details/134656860

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_24936.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除!

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注