关于Qt多线程操作数据库

最新推荐文章于 2023-08-10 18:05:41 发布
最新推荐文章于 2023-08-10 18:05:41 发布
阅读量1.6w 收藏 136
点赞数 19
分类专栏： qt mysql 文章标签： qt sql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a844651990/article/details/82696136
版权
qt 同时被 2 个专栏收录
46 篇文章 26 订阅
订阅专栏
mysql
4 篇文章 0 订阅
订阅专栏

  前几天用Qt写了一个基于线程池的Tcp服务器，发现掉线很频繁，追踪日志发现大多是因为数据库连接名称的冲突导致的，这里记录一下。
  运行环境： ubuntu16 Qt5.9.6

当前线程创建数据库对象和查询对象只能在当前线程中使用，不能跨线程使用

  这里说的是一个线程创建的 QSqlDatabase 对象和 查出来的 QSqlQuery 对象只能在当前线程中使用。一个数据库连接本身比如一个连接的名称是可以在不同线程中使用的。默认连接名称是 “qt_sql_default_connection”

char *QSqlDatabase::defaultConnection = const_cast<char *>("qt_sql_default_connection");

多线程连接数据库

1、共用一个连接

  线程1，创建连接，然后不断地去查询：

void Thread1::run()
{
    for (;;)
    {
        QString connectionName = "connection";
        {
            QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
            db.setHostName("127.0.0.1");
            db.setDatabaseName("testdb");
            db.setUserName("root");
            db.setPassword("1234");
            if (!db.open())
            {
                qDebug() << "thread 1 open db failed!";
            }

            while (1)
            {
                QSqlQuery query("SELECT * FROM testtb", db);
                qDebug() << "thread1 error: " << query.lastError();
                while (query.next())
                {
                    qDebug() << "thread1 value:" << query.value(0).toInt();
                }
                QThread::msleep(100);
            }
        }
    }
}

  线程2，获取线程一创建的连接名称，然后不断地查询：

void Thread2::run()
{
    for (;;)
    {
        QString connectionName = "connection";
        {
            QSqlDatabase db = QSqlDatabase::database(connectionName);
            while (1)
            {
                QSqlQuery query("SELECT * FROM testtb", db);
                qDebug() << "thread2 error: " << query.lastError();
                while (query.next())
                {
                    qDebug() << "thread2 value:" << query.value(0).toInt();
                }
                QThread::msleep(100);
            }
        }
        msleep(100);
    }
}

  main函数：

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Thread1 *th1 = new Thread1;
    th1->start();
    QThread::msleep(100);
    Thread2 *th2 = new Thread2;
    th2->start();
    
	return a.exec();
}

QSqlDatabase::database函数是线程安全的。但是还有一个问题，如果运行上面的代码会出警告：

thread2 error:  QSqlError("2013", "QMYSQL: Unable to execute query", "Lost connection to MySQL server during query")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread2 error:  QSqlError("2006", "QMYSQL: Unable to execute query", "MySQL server has gone away")
thread1 error:  QSqlError("0", "QMYSQL: Unable to execute query", "")

多线程访问一个连接，会存在资源竞争，加锁保护：

...
while (1)
{
    gMutex.lock();
    QSqlQuery query("SELECT * FROM testtb", db);
    qDebug() << "thread1 error: " << query.lastError();
    while (query.next())
    {
        qDebug() << "thread1 value:" << query.value(0).toInt();
    }
    gMutex.unlock();
    QThread::msleep(100);
}
...
while (1)
{
    gMutex.lock();
    QSqlQuery query("SELECT * FROM testtb", db);
    qDebug() << "thread2 error: " << query.lastError();
    while (query.next())
    {
        qDebug() << "thread2 value:" << query.value(0).toInt();
    }
    gMutex.unlock();
    QThread::msleep(100);
}
...

问题解决。

2、多线程动态连接数据库

  动态连接数据库我们采用线程池的方式。为了保证每个线程的连接名称不同，将线程id相关信息设置成连接名称。
  tashk.h:

#ifndef TASK_H
#define TASK_H

#include <QObject>
#include <QRunnable>

class Task : public QObject, public QRunnable
{
    Q_OBJECT
public:
    explicit Task(QObject *parent = nullptr);

    void setType(const int &type);

protected:
    void run();

private:
    void thread1Workder();
    void thread2Workder();
    void thread3Workder();
    void thread4Workder();

private:
    int m_type;
};

#endif // TASK_H

  task.cpp:

#include "task.h"
#include <QDebug>
#include <QThread>
#include <QSqlDatabase>
#include <QDateTime>

Task::Task(QObject *parent)
    : QObject(parent),
      m_type(0)
{
}

void Task::setType(const int &type)
{
    m_type = type;
}

void Task::run()
{
    switch (m_type) {
    case 0:
        thread1Workder();
        break;
    case 1:
        thread2Workder();
        break;
    case 2:
        thread3Workder();
        break;
    case 3:
        thread4Workder();
        break;
    default:
        break;
    }
}

void Task::thread1Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId())); 
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
    db.setHostName("127.0.0.1");
    db.setDatabaseName("testdb");
    db.setUserName("root");
    db.setPassword("1234");
    if (!db.open())
    {
        qDebug() << "thread 1 open db failed!";
    }
    qDebug() << "thread 1: " << QThread::currentThreadId() << connectionName;  
}

void Task::thread2Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId()));
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
    db.setHostName("127.0.0.1");
    db.setDatabaseName("testdb");
    db.setUserName("root");
    db.setPassword("1234");
    if (!db.open())
    {
        qDebug() << "thread 1 open db failed!";
    }
    qDebug() << "thread 2: " << QThread::currentThreadId() << connectionName;
}

void Task::thread3Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId()));
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
    db.setHostName("127.0.0.1");
    db.setDatabaseName("testdb");
    db.setUserName("root");
    db.setPassword("1234");
    if (!db.open())
    {
        qDebug() << "thread 1 open db failed!";
    }
    qDebug() << "thread 3: " << QThread::currentThreadId() << connectionName;
}

void Task::thread4Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId()));
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
    db.setHostName("127.0.0.1");
    db.setDatabaseName("testdb");
    db.setUserName("root");
    db.setPassword("1234");
    if (!db.open())
    {
        qDebug() << "thread 1 open db failed!";
    }
    qDebug() << "thread 4: " << QThread::currentThreadId() << connectionName;
}

main.cpp:

#include <QCoreApplication>
#include <QThreadPool>
#include <QDebug>
#include "task.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    int index = 0;
    for (;;)
    {
        Task *pTask = new Task;
        pTask->setAutoDelete(true);
        pTask->setType(index);
        QThreadPool::globalInstance()->start(pTask);

        index ++;
        if (index > 3)
            index =0;
    }
    return a.exec();
}

  运行结果：

QSqlDatabasePrivate::addDatabase: duplicate connection name '469759744', old connection removed.
QSqlDatabasePrivate::addDatabase: duplicate connection name '701179648', old connection removed.

  发现大量重复连接名称的警告。那我们在每一个线程连接完成之后调用QSqlDatabase::removeDatabase()方法，该方法是线程安全的。如下：

void Task::thread1Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId())); 
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
    db.setHostName("127.0.0.1");
    db.setDatabaseName("testdb");
    db.setUserName("root");
    db.setPassword("1234");
    if (!db.open())
    {
        qDebug() << "thread 1 open db failed!";
    }
    qDebug() << "thread 1: " << QThread::currentThreadId() << connectionName; 
    QSqlDatabase::removeDatabase(connectionName); 
}
void Task::thread2Workder() { ... }
void Task::thread3Workder() { ... }
void Task::thread4Workder() { ... }

  运行时发现还是有警告，大概意思是连接正在使用，将停止工作。

hread 2:  0x7ff658a5f700 "1487271680"
QSqlDatabasePrivate::removeDatabase: connection '1487271680' is still in use, all queries will cease to work.
thread 1 open db failed!
thread 3:  0x7ff659a61700 "1504057088"

调用close()方法也没什么用，查了一下官方文档：
这里写图片描述
  大概意思是不应该在有在该连接上进行数据查询时调用该函数，否则会内存泄露。虽然这里并没有查询任务，但我们按它的方式改下试试：

void Task::thread1Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId()));
    {
        QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
        db.setHostName("127.0.0.1");
        db.setDatabaseName("testdb");
        db.setUserName("root");
        db.setPassword("1234");
        if (!db.open())
        {
            qDebug() << "thread 1 open db failed!";
        }
        qDebug() << "thread 1: " << QThread::currentThreadId() << connectionName;
    }
    QSqlDatabase::removeDatabase(connectionName);
}
void Task::thread2Workder() { ... }
void Task::thread3Workder() { ... }
void Task::thread4Workder() { ... }

  运行发现可以了。不再出现警告了。但是如果运行一段时间会发现程序偶尔会挂掉。。。
原因(https://blog.csdn.net/goldenhawking/article/details/10811409)：
  Qt 会动态的加载数据库的plugin, 加载 plugin 的部分，涉及到对本地库文件的管理，这一部分，出现了竞争。于是，很自然的想到在初始连接部分设置 Mutex 保护，从 addDatabase / database到 open 的部分，要保证其原子性，问题再也没有出现。
再稍微改下，经过大量测试发现正常了：

void Task::thread1Workder()
{
    QString connectionName = QString::number(*static_cast<int*>(QThread::currentThreadId()));
    {
        mutex.lock();
        QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", connectionName);
        db.setHostName("127.0.0.1");
        db.setDatabaseName("testdb");
        db.setUserName("root");
        db.setPassword("1234");
        if (!db.open())
        {
            qDebug() << "thread 1 open db failed!";
        }
        mutex.unlock();
        qDebug() << "thread 1: " << QThread::currentThreadId() << connectionName;
    }
    QSqlDatabase::removeDatabase(connectionName);
}
void Task::thread2Workder() { ... }
void Task::thread3Workder() { ... }
void Task::thread4Workder() { ... }

总结

  1、一个线程创建的数据库对象只能在当前线程使用，但是创建的连接可以多线程使用，唯一需要注意的是，在调用全局方法的时候，要有原子保护。
  2、removedatabase方法是线程安全的，但是在调用的时候确保QSqlDatabase和QSqlQuery等对象已经释放，否则会造成内存泄漏。
  3、多线程访问时不管是同一连接名还是不同连接名称都要进行资源保护。

FlyWM_
关注
专栏目录
QT数据库：在QT中多线程访问mysql数据库的问题（已解决）
吻等离子的博客
07-07 3351
QT使用全局db，提示QSqlDatabasePrivate::database: requested database does not belong to the calling thread.
Qt多线程操作sqlite数据库
最新发布
如山石的系统虚拟化之路
09-30 1250
通过锁解决了sqlite数据库多线程操作的写冲突和读写冲突，锁是有消耗的，但很小，我实测6-19ms,这个消耗算是可以了。多线程操作sqlite数据库，关键之处就是在于加锁，保存同时只有一个写的操作；读的操作是可以并发的；有写的操作，读的操作也必须等待，可以说，同时只有一个写操作，无其它操作，通过锁就达到了这一个目的。如果一个线程正在写，另一个线程也要写，怎么办，锁就会让另一个线程等待前一个线程写完，自己再写。锁的本质意义就是保证了，锁的区域，只有一个写线程在访问，而读的线程，可以并发。
多线程里使用数据库——QtWidgets
xiaopei_yan的博客
08-10 1750
之前没怎么在项目中使用数据库，对数据库这块只了解一点皮毛，只能说能用。这次涉及了在多线程中使用数据库，看了看源码，和吸取了网上的一些经验，整理封装了一下。
Qt 多线程连接数据库——数据库连接池
09-07
* 数据库连接池特点: * 获取连接时不需要了解连接的名字，连接池内部维护连接的名字 * 支持多线程，保证获取到的连接一定是没有被其他线程正在使用 * 按需创建连接,可以创建多个连接,可以控制连接的数量 * 连接被复用，不是每次都重新创建一个新的连接（连接的创建是一个很消耗资源的过程） * 连接断开了后会自动重连 * 当无可用连接时，获取连接的线程会等待一定时间尝试继续获取，直到取到有效连接或者超时返回一个无效的连接 * 关闭连接很简单
Qt 多线程与数据库操作需要注意的几点问题
热门推荐
丁劲犇技术发布空间
08-31 1万+
Qt的数据库操作自成一派，相对于复杂的 ADO \ODBC\DAO\OLEDB 等传统 C++ 访问数据库的方法，还是很先进的，充分体现了 OO 的理念。对数据库的封装，想法是很有意思的。设计者把进程内的数据库连接作为一种资源，每个连接有一个唯一的名字，可以通过全局的 addDatabase, removeDatabase, cloneDatabase 来增删，想用的时候，直接用全局的 database 来获取。这样的好处，是大大节省了开发者的负担。一个线程创建的数据库对象（如 addDatabase 的返
Qt多线程连接数据库
m0_73443478的博客
05-30 1499
Qt多线程连接数据库
Qt 多线程数据库(记录一下)
weixin_42318094的博客
07-17 355
qt 多线程数据库方法尝试,备忘
Qt|多线程线程池处理大量数据写入数据库
奇树谦的博客
02-23 7607
qt多线程读写数据库
qt多线程同时操作mysql_Qt 多线程与数据库操作需要注意的几点问题
weixin_31300697的博客
01-19 874
源地址：http://blog.csdn.net/goldenhawking/article/details/10811409彻底抛弃MFC, 全面应用Qt 已经不少时间了。除了自己看书按步就班做了十几个验证性的应用，还正式做了3个比较大的行业应用，总体感觉很好。Native C++ 下， Qt 基本是我用过的最简便的界面库了。遇到了一些问题，大都解决的很顺利，回头想想，还是有几个问题很有意思，尤...
QT中sqlite多线程操作4个注意问题
07-17
总结了一下Qt中sqlite多线程操作遇到的几个问题，希望能对有需要的朋友一点帮助 总结了一下Qt中sqlite多线程操作遇到的几个问题，希望能对有需要的朋友一点帮助
Qt数据库利用线程读取MySql数据
11-18
利用Qt5代码在VS2010中通过线程QThread读取MySql后台数据库代码显示在界面上！
12.3 Qt5多线程：Qt多线程应用
02-16
Qt5多线程，实现一个多线程的网络时间服务器，每当有客户请求，服务器将启动一个新线程为它返回当前时间，服务完毕后，这个线程自动退出。
多线程访问mysql数据库
01-07
主要分为3部分： 1.DBSqlMan是多线程访问mysql的动态库 2.mysql5，开源的windows下使用的mysql2次开发库，mysql官网上可以下载 3.testDb，简单的应用DBSqlMan的例子 整个工程已经在VS2005下运行通过，并在实际应用中使用过。提供了mysql访问效率 简单讲解下CMySQLMan类的对外接口： SetMaxConnectNum------设置mysql最大的连接数?，当调用ConnectDB的时候会创建X个数据库连接 SetCharset------设置编码格式，主要是GB2312还是UTF8 ConnectDB------连接数据库 GetIdleMySql------获取一个未使用的mysql连接 ReleaseMysql------释放一个在使用的mysql连接 SelectRecordbySP/SelectRecord------都是执行一个sql语句，返回一个结果集（主要用于查询） FreeRecord------释放结果集 ExecSP/ExecSQL------都是执行一个sql语句（主要用于插入，删除） 其他接口主要是后续扩展的，比如获取表字段，对表进行加减锁，获取计算机信息等，不是核心的接口，不做解释
[QT] 多线程访问数据库
zc_674452358的博客
04-07 777
QString connectionName = "read_connect"; { QSqlDatabase database; if (QSqlDatabase::contains(connectionName)) //检测连接是否存在 { database = QSqlDatabase::database(connectionName); } else { ...
QT--多线程与MySQL数据库
我有一颗薄荷糖的博客
10-28 2063
关于QT中多线程和数据库的应用
Qt笔记-多线程检索数据库（单例多重锁，QtConcurrent::blockingMapped）
hw5230的博客
04-28 311
原文链接：https://it1995.blog.csdn.net/article/details/108592327。MySQLInstance采用单例双重锁模式对数据库进行操作。这里有下面这个类BigDataTest对数据进行的类。这里主要是个事例，并不涉及业务逻辑处理。
qt多线程同时操作mysql_多个SQLite数据库实例在不同的线程（QT）上同时打开
weixin_35238815的博客
01-19 767
Is there any problem on using many open connections at the same time from different threads?From what I've read it's thread safe by default, but, can this be hurting performance rather than improving ...
qt中线程操作数据库
12-05
在Qt中，线程操作数据库是一个常见的需求。通过使用Qt的数据库模块和多线程支持，可以在单独的线程中执行数据库操作，以提高程序的性能和响应速度。 首先，需要在主线程中创建数据库连接，并获取数据库操作对象。然后，可以创建一个新的线程，在该线程中执行数据库操作。可以使用Qt的QThread类来创建新线程，并使用信号和槽机制来实现线程间的通信。 在新线程中，可以使用数据库模块提供的类来执行各种数据库操作，例如查询数据、插入数据、更新数据和删除数据等。需要注意的是，为了避免数据库操作的竞态条件和数据访问冲突，需要使用适当的线程同步机制来保证数据库操作的正确性和一致性。 另外，在进行数据库操作的过程中，需要处理数据库操作的结果和错误。可以通过信号和槽机制将数据库操作的结果发送回主线程，以便更新UI界面或者进行其他操作。 总的来说，通过在Qt中使用多线程来操作数据库，可以提高程序的性能和响应速度，同时也可以提高程序的健壮性和可维护性。当然，在进行线程操作数据库时，也需要注意线程安全和数据一致性的相关问题，以确保程序的正确运行。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值