Qt多线程入门

最新推荐文章于 2024-06-18 17:10:01 发布
最新推荐文章于 2024-06-18 17:10:01 发布
阅读量660 收藏 5
点赞数 1
分类专栏： CPP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42145502/article/details/97519186
版权

1.啥是多线程？

学习视频：https://www.bilibili.com/video/av4056436?from=search&seid=17245833892440413059

参考文章：https://blog.csdn.net/yao5hed/article/details/81108507

        线程是操作系统中运算调度的最小单位，不需要拥有自己独立的内存空间。共享进程的内存空间，拥有独立的栈。

进程支持多线程，但必须有一个主线程，多个线程之间是相互独立的。

       主线程具有特殊性，其他的线程都是通过主线直接、间接启动的。主线程结束，其他的所有线程都要结束。

       多线程就是分时利用CPU，宏观上让所有线程一起执行 ，也叫并发

       主线程：          

 

线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

实现并启动线程有两种方法

1、写一个类继承自Thread类，重写run方法。用start方法启动线程

2、写一个类实现Runnable接口，实现run方法。用new Thread(Runnable target).start()方法来启动

调用start（）后，线程会被放到等待队列，等待CPU调度， 并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。 先调用start后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。
1.start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。  然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
2.run（）方法当作普通方法的方式调用。程序还是要顺序执行， 要等待run方法体执行完毕后，才可继续执行下面的代码；程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。

 

 

2.代码：

test
main.cpp
-----------------------------------------------------------------------------------------
#include <QCoreApplication>
#include  <algorithm>
#include  <ctime>
#include  <Qtcore>
#include  <QSet>
#include  "mythread.h"
#include <QDebug>
#include <QMutex> //互斥锁
#include <QtConcurrent> //需要在.pro中加入concurrent
#include <myclass.h>
//2019-07-27-ThreaDemo
//main是一个主线程，主线结束，子线程也自动结束
//主线程与子线程占用不同的内存空间
//使用互斥锁是用来保证在任意一时刻，只有一个线程进行访问，线程阻塞，会明显的拖慢时间，造成假死，不能频繁的使用锁
//避免死锁；一个lock 配对一个unlock
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 //匿名函数测试
//    int n=[=](int a,int b){return a+b;}(5,4);
//    qDebug()<<"Lambdatest:"<<n;  //C++11 也要的早pro文件中配置一下

    qDebug()<<"main thread:"<<QThread::currentThread();//打印当前的线程的地址//主要是用来验证主子线程不在同一个内存空间，完成独立的
    QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test1.txt";//===存储路径
    QByteArray data ="Hello,my thread";
/**************************************************************************************/
//例子1使用concurrent 高级线程API---做一些简单的操作
//    QtConcurrent::run([=](){ //中括号用于捕获，测试成功，代码量非常的简单。
//实际运行在子线程中
//     qDebug()<<"QtConcurrent:"<<QThread::currentThread();
//               QFile file(filepath); //创建文件路径
//               file.open(QIODevice::WriteOnly);
//               file.write(data);
//               file.waitForBytesWritten(30*1000);
//    });
/****************************************************************************************/
//例子2使用一般的Qthread：假设需要保存一个数据在子线程中执行，执行的内容放在的run中进行实现
//   QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test.txt";//===存储路径
//   QByteArray data ="Hello,my thread";
//   MyThread  myThread(filepath,data); //初始化操作
//   myThread.start();
/*****************************************************************************************/
//线程池例子3在线程池中开启四个线程
//    QMutex mutex;//实例化一个互斥锁
//    //在set设置增删改查

//    QSet< int > data1; //实例化
//    qDebug()<<QThreadPool::globalInstance()->maxThreadCount(); //打印线程的数量根据物理CPU而决定
//    QThreadPool threadPool;//实例化线程池
//    threadPool.setMaxThreadCount(4);
//    循环等待加锁
//    while(true)
//    {
//        if(!mutex.tryLock)
//        {
//            qDebug()<<"moreWait";
//        }else
//        {
//            break; //加上锁了
//        }
        
//    }
//    QtConcurrent::run(&threadPool,[&](){ //使用&捕获锁
// //        while(true) //死循环
//      for(atuo i=1;i<1000;i++) //auto可以自动推断类型
//        {  //插入数据之前，先记性锁住---保证当前线程在访问当中，其他线程等着爸爸
//            mutex.lock();
//            data1.insert(rand()%1000); //it=data1.insert(rand()%1000);==QSet<int>::const_iterator it=data1.insert
//           //插入完数据后,就进行解锁
//            mutex.unlock();
//        }

//    });

//    //删
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            //寻找迭代器
//            auto it =data1.find(rand()%1000);
//            if(it!=data1.end())
//            {
//             data1.insert(rand()%1000);
//            }
//            mutex.unlock();
//        }

//    });
//    //改
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {  mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//    //查
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//      threadPool.waitPorDone(); //等待所有的线程结束
/*************************************************************************/
//例4 采用信号槽与线程结合
   Sender sender; //信号的发送方(生存线程即主线程)
   QtConcurrent::run([&](){
   Receive receiver; //接收方是自己开启的一个子线程
   //转移线程操作
  //  receiver.moveToThread(qApp->thread());//由线程转移到主线程
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive); //创建连接默认采用自动连接选择直接连接可以省略不写但是必须注
  // 采用直接连接的方式：槽运行发出的信号的线程，这里发出信号的线程就是主线程，机槽运行在主线程中
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::DirectConnection);//直接连接与上面连接方式是一致的
  //采用队列的方式联机，槽运行在接收信号对象的生存线程，依赖于事件循环，槽运行在子线程中
   QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::QueuedConnection);//队列连接
   QEventLoop eventLoop;
   eventLoop.exec();//启动事件循环--=-直连不需要事件循环，如果是队列连接需要进行事件循环
   });
   QThread::sleep(1);
   emit sender.mySignal(); //发射信号
    return a.exec();
}

 

mythread.h
------------------------------------------------------------------------------------
#include <QCoreApplication>
#include  <algorithm>
#include  <ctime>
#include  <Qtcore>
#include  <QSet>
#include  "mythread.h"
#include <QDebug>
#include <QMutex> //互斥锁
#include <QtConcurrent> //需要在.pro中加入concurrent
#include <myclass.h>
//2019-07-27-ThreaDemo
//main是一个主线程，主线结束，子线程也自动结束
//主线程与子线程占用不同的内存空间
//使用互斥锁是用来保证在任意一时刻，只有一个线程进行访问，线程阻塞，会明显的拖慢时间，造成假死，不能频繁的使用锁
//避免死锁；一个lock 配对一个unlock
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 //匿名函数测试
//    int n=[=](int a,int b){return a+b;}(5,4);
//    qDebug()<<"Lambdatest:"<<n;  //C++11 也要的早pro文件中配置一下

    qDebug()<<"main thread:"<<QThread::currentThread();//打印当前的线程的地址//主要是用来验证主子线程不在同一个内存空间，完成独立的
    QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test1.txt";//===存储路径
    QByteArray data ="Hello,my thread";
/**************************************************************************************/
//例子1使用concurrent 高级线程API---做一些简单的操作
//    QtConcurrent::run([=](){ //中括号用于捕获，测试成功，代码量非常的简单。
//实际运行在子线程中
//     qDebug()<<"QtConcurrent:"<<QThread::currentThread();
//               QFile file(filepath); //创建文件路径
//               file.open(QIODevice::WriteOnly);
//               file.write(data);
//               file.waitForBytesWritten(30*1000);
//    });
/****************************************************************************************/
//例子2使用一般的Qthread：假设需要保存一个数据在子线程中执行，执行的内容放在的run中进行实现
//   QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test.txt";//===存储路径
//   QByteArray data ="Hello,my thread";
//   MyThread  myThread(filepath,data); //初始化操作
//   myThread.start();
/*****************************************************************************************/
//线程池例子3在线程池中开启四个线程
//    QMutex mutex;//实例化一个互斥锁
//    //在set设置增删改查

//    QSet< int > data1; //实例化
//    qDebug()<<QThreadPool::globalInstance()->maxThreadCount(); //打印线程的数量根据物理CPU而决定
//    QThreadPool threadPool;//实例化线程池
//    threadPool.setMaxThreadCount(4);
//    循环等待加锁
//    while(true)
//    {
//        if(!mutex.tryLock)
//        {
//            qDebug()<<"moreWait";
//        }else
//        {
//            break; //加上锁了
//        }
        
//    }
//    QtConcurrent::run(&threadPool,[&](){ //使用&捕获锁
// //        while(true) //死循环
//      for(atuo i=1;i<1000;i++) //auto可以自动推断类型
//        {  //插入数据之前，先记性锁住---保证当前线程在访问当中，其他线程等着爸爸
//            mutex.lock();
//            data1.insert(rand()%1000); //it=data1.insert(rand()%1000);==QSet<int>::const_iterator it=data1.insert
//           //插入完数据后,就进行解锁
//            mutex.unlock();
//        }

//    });

//    //删
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            //寻找迭代器
//            auto it =data1.find(rand()%1000);
//            if(it!=data1.end())
//            {
//             data1.insert(rand()%1000);
//            }
//            mutex.unlock();
//        }

//    });
//    //改
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {  mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//    //查
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//      threadPool.waitPorDone(); //等待所有的线程结束
/*************************************************************************/
//例4 采用信号槽与线程结合
   Sender sender; //信号的发送方(生存线程即主线程)
   QtConcurrent::run([&](){
   Receive receiver; //接收方是自己开启的一个子线程
   //转移线程操作
  //  receiver.moveToThread(qApp->thread());//由线程转移到主线程
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive); //创建连接默认采用自动连接选择直接连接可以省略不写但是必须注
  // 采用直接连接的方式：槽运行发出的信号的线程，这里发出信号的线程就是主线程，机槽运行在主线程中
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::DirectConnection);//直接连接与上面连接方式是一致的
  //采用队列的方式联机，槽运行在接收信号对象的生存线程，依赖于事件循环，槽运行在子线程中
   QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::QueuedConnection);//队列连接
   QEventLoop eventLoop;
   eventLoop.exec();//启动事件循环--=-直连不需要事件循环，如果是队列连接需要进行事件循环
   });
   QThread::sleep(1);
   emit sender.mySignal(); //发射信号
    return a.exec();
}

myclass
------------------------------------------------------------------------------------
#include <QCoreApplication>
#include  <algorithm>
#include  <ctime>
#include  <Qtcore>
#include  <QSet>
#include  "mythread.h"
#include <QDebug>
#include <QMutex> //互斥锁
#include <QtConcurrent> //需要在.pro中加入concurrent
#include <myclass.h>
//2019-07-27-ThreaDemo
//main是一个主线程，主线结束，子线程也自动结束
//主线程与子线程占用不同的内存空间
//使用互斥锁是用来保证在任意一时刻，只有一个线程进行访问，线程阻塞，会明显的拖慢时间，造成假死，不能频繁的使用锁
//避免死锁；一个lock 配对一个unlock
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 //匿名函数测试
//    int n=[=](int a,int b){return a+b;}(5,4);
//    qDebug()<<"Lambdatest:"<<n;  //C++11 也要的早pro文件中配置一下

    qDebug()<<"main thread:"<<QThread::currentThread();//打印当前的线程的地址//主要是用来验证主子线程不在同一个内存空间，完成独立的
    QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test1.txt";//===存储路径
    QByteArray data ="Hello,my thread";
/**************************************************************************************/
//例子1使用concurrent 高级线程API---做一些简单的操作
//    QtConcurrent::run([=](){ //中括号用于捕获，测试成功，代码量非常的简单。
//实际运行在子线程中
//     qDebug()<<"QtConcurrent:"<<QThread::currentThread();
//               QFile file(filepath); //创建文件路径
//               file.open(QIODevice::WriteOnly);
//               file.write(data);
//               file.waitForBytesWritten(30*1000);
//    });
/****************************************************************************************/
//例子2使用一般的Qthread：假设需要保存一个数据在子线程中执行，执行的内容放在的run中进行实现
//   QString filepath="C:/Users/lenovo/Desktop/ThreadDemo/test.txt";//===存储路径
//   QByteArray data ="Hello,my thread";
//   MyThread  myThread(filepath,data); //初始化操作
//   myThread.start();
/*****************************************************************************************/
//线程池例子3在线程池中开启四个线程
//    QMutex mutex;//实例化一个互斥锁
//    //在set设置增删改查

//    QSet< int > data1; //实例化
//    qDebug()<<QThreadPool::globalInstance()->maxThreadCount(); //打印线程的数量根据物理CPU而决定
//    QThreadPool threadPool;//实例化线程池
//    threadPool.setMaxThreadCount(4);
//    循环等待加锁
//    while(true)
//    {
//        if(!mutex.tryLock)
//        {
//            qDebug()<<"moreWait";
//        }else
//        {
//            break; //加上锁了
//        }
        
//    }
//    QtConcurrent::run(&threadPool,[&](){ //使用&捕获锁
// //        while(true) //死循环
//      for(atuo i=1;i<1000;i++) //auto可以自动推断类型
//        {  //插入数据之前，先记性锁住---保证当前线程在访问当中，其他线程等着爸爸
//            mutex.lock();
//            data1.insert(rand()%1000); //it=data1.insert(rand()%1000);==QSet<int>::const_iterator it=data1.insert
//           //插入完数据后,就进行解锁
//            mutex.unlock();
//        }

//    });

//    //删
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            //寻找迭代器
//            auto it =data1.find(rand()%1000);
//            if(it!=data1.end())
//            {
//             data1.insert(rand()%1000);
//            }
//            mutex.unlock();
//        }

//    });
//    //改
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {  mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//    //查
//    QtConcurrent::run(&threadPool,[&](){
//       for(atuo i=1;i<1000;i++)
//        {
//            mutex.lock();
//            data1.find(rand()%1000);
//            mutex.unlock();
//        }

//    });
//      threadPool.waitPorDone(); //等待所有的线程结束
/*************************************************************************/
//例4 采用信号槽与线程结合
   Sender sender; //信号的发送方(生存线程即主线程)
   QtConcurrent::run([&](){
   Receive receiver; //接收方是自己开启的一个子线程
   //转移线程操作
  //  receiver.moveToThread(qApp->thread());//由线程转移到主线程
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive); //创建连接默认采用自动连接选择直接连接可以省略不写但是必须注
  // 采用直接连接的方式：槽运行发出的信号的线程，这里发出信号的线程就是主线程，机槽运行在主线程中
  // QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::DirectConnection);//直接连接与上面连接方式是一致的
  //采用队列的方式联机，槽运行在接收信号对象的生存线程，依赖于事件循环，槽运行在子线程中
   QObject::connect(&sender,&Sender::mySignal,&receiver,&Receive::onReceive,Qt::QueuedConnection);//队列连接
   QEventLoop eventLoop;
   eventLoop.exec();//启动事件循环--=-直连不需要事件循环，如果是队列连接需要进行事件循环
   });
   QThread::sleep(1);
   emit sender.mySignal(); //发射信号
    return a.exec();
}

 

 

 

 

 

一禅的师兄
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Qt之QThread（深入理解）
weixin_34194359的博客
08-11 6021
简述 为了让程序尽快响应用户操作，在开发应用程序时经常会使用到线程。对于耗时操作如果不使用线程，UI界面将会长时间处于停滞状态，这种情况是用户非常不愿意看到的，我们可以用线程来解决这个问题。 前面，已经介绍了QThread常用的两种方式： Worker-Object 子类化QThread 下面，我们来看看子类化QThread在...
Qt多线程
qq_42138448的博客
05-17 272
Qt 4.0线程使用方式，值得注意的是，在MyThread 类中只有run()函数才是唯一的线程处理函数，即在run()函数中的线程和主线程中的线程号是不一样的。 MyThread 类在主线程中不能直接调用run()函数，通过start()函数间接调用run()函数。 在Qt线程中创建线程步骤 首先创建一个新类，该类继承于QObject。在QObject类中进行下列修改，便能成为QThread 。 MyThread.h MyThread.cpp ...
Qt 线程池(QThreadPool )的使用
12-14
Qt 使用线程池 构建 多线程 多任务 代码是自己写的小demo 可以直接运行
Qt之多线程、信号和槽
yi_chengyu的博客
05-31 7157
Qt多线程和信号槽相遇时的用法
Qt 线程
最新发布
m0_64028711的博客
06-18 987
本文总结了 Qt 的线程类，以及配套的用于线程安全的互斥锁、条件变量和信号量，相信对大家会有所帮助。
QT（11）- QThread
m晴朗的博客
02-10 917
QThread：具有可选事件循环的低级 API QThread是 Qt 中所有线程控制的基础。每个QThread实例表示并控制一个线程。 QThread可以直接实例化，也可以子类化。实例化QThread提供了一个并行事件循环，允许在辅助线程中调用QObject插槽。对 QThread进行子类化允许应用程序在启动其事件循环之前初始化新线程，或者在没有事件循环的情况下运行并行代码。 QThread 会在线程运行时通过信号通知你started（） 和finished(), 或者你可以使用isFinished（
【Qt线程-6】获取当前线程id，thread()和currentThreadId()，不是想当然那样，不使用信号槽可能看不出区别
大橘子的博客
08-17 4711
QThread *thd = new QThread仅仅是构造了一个指针对象，它代表不了真正意义上的线程。它的生存线程依然是父线程。
Qt 多线程
wuchalilun的专栏
06-28 609
这两天在研究Qt的多线程，之前一直被搞的有点迷糊，一会儿是子线程执行，一会儿是主线程执行，刚开始以为子线程只能执行run函数中的带代码，现在发现并不然。。 自己也是查了大量资料才有所收货的，有一篇文章写的还是不错的，http://blog.csdn.net/lutx/article/details/7353957，大家可以看看，我也是借鉴了这篇博客。 1. 首先觉得自己忽略了一个问题，
QT多线程小例子.zip
03-15
本例中的"QT多线程小例子.zip"提供了两种在QT中实现多线程的方法，适用于QT5.7.0版本。 首先，我们来看"01Thread"这个例子，它展示了QT4中的多线程处理方式。在QT4中，我们可以使用QThread类直接创建和管理线程。在...
QT5 编程入门
03-16
对于多线程，QT5提供了QThread类，使得开发者能够在不同的线程中执行任务，提高程序的响应速度和性能。不过，需要注意的是，QT的线程模型强调了对象的所有权和事件循环，理解这一点对于正确使用QThread至关重要。 ...
用QT自带的多线程使用实例
03-23
在标题"用QT自带的多线程使用实例"中，我们可以聚焦于QT4.8版本下如何在32位系统中利用其内置的多线程功能进行程序设计。多线程技术在现代软件开发中扮演着重要角色，它允许程序同时执行多个任务，提升程序的执行...
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
08-11
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
Qt 入门教程
01-04
Qt库提供了丰富的API，涵盖了窗口管理、图形绘制、网络通信、数据库访问、多线程、XML处理等多个方面，使得开发者能够快速构建功能丰富的应用程序。在本教程中，你将学习到如何使用Qt来设计和实现用户界面，掌握基本...
Qt多线程-QThread
coologic
12-12 455
介绍 QThread是Qt提供的线程类，每一个QThread均可管理一个线程。 其具有两种使用方式：1、继承为QThread的子类；2、继承为QObject的子类，并使用QObject::moveToThread将此对象移到线程中运行 QThread提供了如下基本函数： 线程启动：start()运行一次 线程终止：terminate 终止线程，强制终止线程但会依据操作系统的调度策...
一种简单实现QT多线程的方法
xiaoliming1的博客
08-05 523
一种简单实现QT多线程的方法 前言 在QT中实现多线程的方法有很多种，但实现过程往往非常繁琐，这里给大家介绍一种比较简单的实现QT多线程的方法 首先编写一个专门用来提供线程的线程类 1.头文件包含 #include <functional> #include <QRunnable> #include <QThread> 2.给模板类std::function<void()>起别名为function typedef std::function<vo
Qt - 获取系统当前时间
QtCompany的博客
09-11 2293
Qt获取系统当前时间的四种方法（一般使用第一种或者第二种）
Qt线程知识总结——QThread
pangyinglong的博客
07-26 1546
Qt中线程支持的内容 1、与平台无关的线程类，一个线程安全的发送事件的方式以及跨线程的信号-槽的关联。 2、一个QThread代表了一个应用程序中可以独立控制的线程，与进程中的其他线程分享数据，独立执行。 3、QThread从run()函数开始执行。 4、默认的，run()函数通过调用exec()来开启事件循环，并在线程内运行一个Qt事件循环。 创建一个线程 1、子类化QThr...
QThread必须要了解的几个函数
HuZhenXing
08-11 3万+
概述     如果想对Qt中的QThread有个更加深刻的了解，必须要知道这几个重要的函数，现在就一一介绍下。 函数介绍 属性 返回值 函数体 功能 static QThread * QThread::currentThread()     返回当前线程的指针，静态函数。 static Qt::HAND
【Qt】Qt的线程（两种QThread类的详细使用方式）
热门推荐
Yngz_Miao的博客
11-26 5万+
Qt提供QThread类以进行多任务处理。与多任务处理一样，Qt提供的线程可以做到单个线程做不到的事情。例如，网络应用程序中，可以使用线程处理多种连接器。 QThread继承自QObject类，且提供QMutex类以实现同步。线程和进程共享全局变量，可以使用互斥体对改变后的全局变量值实现同步。因此，必须编辑全局数据时，使用互斥体实现同步，其它进程则不能改变或浏览全局变量值。 什么是互斥体？ ...
Qt线程编程入门：创建与同步
"qt学习资料，适合初学者研究Qt界面设计和多线程技术，包含QThread、QThreadStorage、QMutex等关键类的使用示例" 在Qt库中，多线程支持是通过一系列精心设计的类来实现的，这些类提供了线程创建、同步和通信的能力...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值