多线程简易实例

最新推荐文章于 2024-08-15 19:01:20 发布
最新推荐文章于 2024-08-15 19:01:20 发布
阅读量553 收藏
点赞数 1
文章标签： ui qt c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52408666/article/details/126266935
版权

前言

（通过反复创建二进制文件根据创建时间推测电脑性能）

本文创建了一个具备基础多线程的一个小实例，主要是靠对一个二进制文件的读取后存入数组，然后重复创建二进制文件并把数组塞入，根据创建相同的文件数所耗费的时间来判断性能。

提示：以下是本篇文章正文内容，下面案例可供参考

一、主线程头文件

#ifndef CREADANDWRITE_H
#define CREADANDWRITE_H
#include<QTime>
#include<QFile>
#include<QDataStream>
#include<QDebug>
#include<QVector>
#include<QThread>
#include <QWidget>
#include<mythread.h>
#include<mythread1.h>
#include<mythread2.h>
#include<mythread3.h>
#include<mythread4.h>
#include<QFileDialog>

namespace Ui {
class CReadAndWrite;
}

class CReadAndWrite : public QWidget
{
    Q_OBJECT

signals:
    void MyThreadForVector(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
    void MyThreadForVector1(QVector<qint16> r,QVector<qint8> t,QVector<qint32> y,QString);
    void MyThreadForVector2(QVector<qint16> u,QVector<qint8> i,QVector<qint32> o,QString);
    void MyThreadForVector3(QVector<qint16> u,QVector<qint8> i,QVector<qint32> o,QString);
    void MyThreadForVector4(QVector<qint16> u,QVector<qint8> i,QVector<qint32> o,QString);

public:
    explicit CReadAndWrite(QWidget *parent = 0);
    ~CReadAndWrite();
    void createView();
    QVector<qint16> twoNum;
    QVector<qint8> oneNum;
    QVector<qint32> fourNum;
    QString path1;
    MyThread *thread1;
    MyThread1 *thread2;
    MyThread2 *thread3;
    MyThread3 *thread4;
    MyThread4 *thread5;

private:
    Ui::CReadAndWrite *ui;
    QThread *firstThread;
    QThread *secondThread;
    QThread *thirdThread;
    QThread *fourThread;
    QThread *fiveThread;

private slots:
    void on_readBtn_clicked();
};

#endif // CREADANDWRITE_H

二、主线程CPP文件

#include "creadandwrite.h"
#include "ui_creadandwrite.h"

CReadAndWrite::CReadAndWrite(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::CReadAndWrite)
{
    ui->setupUi(this);
    createView();
}

void CReadAndWrite::createView()
{
    firstThread = new QThread;//线程容器
    secondThread = new QThread;//线程容器
    thirdThread = new QThread;//线程容器
    fourThread = new QThread;//线程容器
    fiveThread = new QThread;//线程容器

    thread1 = new MyThread();//创建自定义线程
    thread2 = new MyThread1();//创建自定义线程
    thread3 = new MyThread2();//创建自定义线程
    thread4 = new MyThread3();//创建自定义线程
    thread5 = new MyThread4();//创建自定义线程

    thread1->moveToThread(firstThread); //将创建的对象移到线程容器中
    thread2->moveToThread(secondThread); //将创建的对象移到线程容器中
    thread3->moveToThread(thirdThread); //将创建的对象移到线程容器中
    thread4->moveToThread(fourThread); //将创建的对象移到线程容器中
    thread5->moveToThread(fiveThread); //将创建的对象移到线程容器中

    QObject::connect(this,SIGNAL(MyThreadForVector(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)),thread1,SLOT(getaddress(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)));
    QObject::connect(this,SIGNAL(MyThreadForVector1(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)),thread2,SLOT(getaddress(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)));
    QObject::connect(this,SIGNAL(MyThreadForVector2(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)),thread3,SLOT(getaddress(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)));
    QObject::connect(this,SIGNAL(MyThreadForVector3(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)),thread4,SLOT(getaddress(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)));
    QObject::connect(this,SIGNAL(MyThreadForVector4(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)),thread5,SLOT(getaddress(QVector<qint16>,QVector<qint8>,QVector<qint32>,QString)));

    firstThread->start();
    secondThread->start();
    thirdThread->start();
    fourThread->start();
    fiveThread->start();

    QFile file = QFileDialog::getOpenFileName(this,"choose src Directory","C:/.dat");
    if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return;
    QDataStream stream1(&file);
    qint16 a;
    qint8 b;
    qint32 c;

    for(int i=0;i<2208*2000;i++)
    {
        stream1>>a;
        twoNum.append(a);
    }

    for(int i=0;i<2208*2000;i++)
    {
        stream1>>b;
        oneNum.append(b);
    }

    for(int i=0;i<2000;i++)
    {
        stream1>>c;
        fourNum.append(c);
    }
}

void CReadAndWrite::on_readBtn_clicked()
{
    path1 = QFileDialog::getExistingDirectory(this,"","");
    QString a = ui->mathlineEdit->text();
    int b = a.toInt();
    QTime time;
    time.start();
    for(int x=0;x<b;x++)
    {
        if(x%6 == 0)
        {
            QFile file2;
            QString fileName = path1+"/" + QString::number(x) + "test.dat";
            file2.setFileName(fileName);
            if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
                return;
            QDataStream stream(&file2);
            stream.setByteOrder(QDataStream::LittleEndian);
            stream<<twoNum;
            stream<<oneNum;
            stream<<fourNum;
            file2.close();
        }
        else if(x%6 == 1)
        {
            emit MyThreadForVector(twoNum,oneNum,fourNum,path1);
        }
        else if(x%6 == 2)
        {
            emit MyThreadForVector1(twoNum,oneNum,fourNum,path1);
        }
        else if(x%6 == 3)
        {
            emit MyThreadForVector2(twoNum,oneNum,fourNum,path1);
        }
        else if(x%6 == 4)
        {
            emit MyThreadForVector3(twoNum,oneNum,fourNum,path1);
        }
        else if(x%6 == 5)
        {
            emit MyThreadForVector4(twoNum,oneNum,fourNum,path1);
        }
    }
    qDebug()<<time.elapsed()/1000.0<<"s";
    ui->lineEdit->setText(QString::number(time.elapsed()/1000.0));
}

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

三、分线程1头文件

代码如下（示例）：

#ifndef MYTHREAD_H
#define MYTHREAD_H
#include<QVector>
#include<QThread>

class MyThread:public QObject
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = 0);
    int i;

private:
    volatile bool isStop;
    QVector<qint16> Num1;
    QVector<qint8> Num2;
    QVector<qint32> Num3;
    QString path;

public slots:
    void getaddress(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
};

#endif // MYTHREAD_H

四、分线程1CPP文件

代码如下（示例）：

#include "mythread.h"
#include<QTime>
#include<QDataStream>
#include<QDebug>
#include<QFile>

MyThread::MyThread(QObject *parent)
{
    i = 1;
}

void MyThread::getaddress(QVector<qint16> a, QVector<qint8> b, QVector<qint32> c,QString d)
{
    Num1 = a;
    Num2 = b;
    Num3 = c;
    path = d;
    QFile file2(path + "/" + QString::number(i) + "test.dat");
    i = i + 6;
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return;
    QDataStream stream(&file2);
    stream.setByteOrder(QDataStream::LittleEndian);
    stream<<Num1;
    stream<<Num2;
    stream<<Num3;
    file2.close();
}

五、分线程2头文件

代码如下（示例）：

#ifndef MYTHREAD1_H
#define MYTHREAD1_H
#include<QVector>
#include<QThread>

class MyThread1:public QObject
{
    Q_OBJECT
public:
    explicit MyThread1(QObject *parent = 0);
    int i;

private:
    volatile bool isStop;
    QVector<qint16> Num1;
    QVector<qint8> Num2;
    QVector<qint32> Num3;
    QString path;

public slots:
    void getaddress(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
};

#endif // MYTHREAD1_H

六、分线程2CPP文件

代码如下（示例）：

#include "mythread1.h"
#include<QTime>
#include<QDataStream>
#include<QDebug>
#include<QFile>

MyThread1::MyThread1(QObject *parent)
{
    i = 2;
}

void MyThread1::getaddress(QVector<qint16> a, QVector<qint8> b, QVector<qint32> c,QString d)
{
    Num1 = a;
    Num2 = b;
    Num3 = c;
    path = d;
    QFile file2(path + "/" + QString::number(i) + "test.dat");
    i = i + 6;
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return;
    QDataStream stream(&file2);
    stream.setByteOrder(QDataStream::LittleEndian);
    stream<<Num1;
    stream<<Num2;
    stream<<Num3;
    file2.close();
}

七、分线程3头文件

代码如下（示例）：

#ifndef MYTHREAD2_H
#define MYTHREAD2_H
#include<QVector>
#include<QThread>

class MyThread2:public QObject
{
    Q_OBJECT
public:
    explicit MyThread2(QObject *parent = 0);
    int i;

private:
    volatile bool isStop;
    QVector<qint16> Num1;
    QVector<qint8> Num2;
    QVector<qint32> Num3;
    QString path;

public slots:
    void getaddress(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
};

#endif // MYTHREAD2_H

八、分线程3CPP文件

代码如下（示例）：

#include "mythread2.h"
#include<QTime>
#include<QDataStream>
#include<QDebug>
#include<QFile>

MyThread2::MyThread2(QObject *parent)
{
    i = 3;
}

void MyThread2::getaddress(QVector<qint16> a, QVector<qint8> b, QVector<qint32> c,QString d)
{
    Num1 = a;
    Num2 = b;
    Num3 = c;
    path = d;
    QFile file2(path + "/" + QString::number(i) + "test.dat");
    i = i + 6;
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return;
    QDataStream stream(&file2);
    stream.setByteOrder(QDataStream::LittleEndian);
    stream<<Num1;
    stream<<Num2;
    stream<<Num3;
    file2.close();
}

九、分线程4头文件

代码如下（示例）：

#ifndef MYTHREAD3_H
#define MYTHREAD3_H
#include<QVector>
#include<QThread>

class MyThread3:public QObject
{
    Q_OBJECT
public:
    explicit MyThread3(QObject *parent = 0);
    int i;

private:
    volatile bool isStop;
    QVector<qint16> Num1;
    QVector<qint8> Num2;
    QVector<qint32> Num3;
    QString path;

public slots:
    void getaddress(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
};

#endif // MYTHREAD3_H

十、分线程4CPP文件

代码如下（示例）：

#include "mythread3.h"
#include<QTime>
#include<QDataStream>
#include<QDebug>
#include<QFile>

MyThread3::MyThread3(QObject *parent)
{
    i = 4;
}

void MyThread3::getaddress(QVector<qint16> a, QVector<qint8> b, QVector<qint32> c,QString d)
{
    Num1 = a;
    Num2 = b;
    Num3 = c;
    path = d;
    QFile file2(path + "/" + QString::number(i) + "test.dat");
    i = i + 6;
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return;
    QDataStream stream(&file2);
    stream.setByteOrder(QDataStream::LittleEndian);
    stream<<Num1;
    stream<<Num2;
    stream<<Num3;
    file2.close();
}

十一、分线程5头文件

代码如下（示例）：

#ifndef MYTHREAD4_H
#define MYTHREAD4_H
#include<QVector>
#include<QThread>

class MyThread4:public QObject
{
    Q_OBJECT
public:
    explicit MyThread4(QObject *parent = 0);
    int i;

private:
    volatile bool isStop;
    QVector<qint16> Num1;
    QVector<qint8> Num2;
    QVector<qint32> Num3;
    QString path;

public slots:
    void getaddress(QVector<qint16> q,QVector<qint8> w,QVector<qint32> e,QString);
};

#endif // MYTHREAD4_H

十二、分线程5CPP文件

代码如下（示例）：

#include "mythread4.h"
#include<QTime>
#include<QDataStream>
#include<QDebug>
#include<QFile>

MyThread4::MyThread4(QObject *parent)
{
    i = 5;
}

void MyThread4::getaddress(QVector<qint16> a, QVector<qint8> b, QVector<qint32> c,QString d)
{
    Num1 = a;
    Num2 = b;
    Num3 = c;
    path = d;
    QFile file2(path + "/" + QString::number(i) + "test.dat");
    i = i + 6;
    if (!file2.open(QIODevice::WriteOnly | QIODevice::Truncate))
        return;
    QDataStream stream(&file2);
    stream.setByteOrder(QDataStream::LittleEndian);
    stream<<Num1;
    stream<<Num2;
    stream<<Num3;
    file2.close();
}

十三、main.cpp

代码如下（示例）：

#include "creadandwrite.h"
#include <QApplication>
#include <QMetaType>
#include<QVector>

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

//    Q_DECLARE_METATYPE(QVector<qint16>);
    qRegisterMetaType<QVector<qint16>>("QVector<qint16>");

    qRegisterMetaType<QVector<qint8>>("QVector<qint8>");

    qRegisterMetaType<QVector<qint32>>("QVector<qint32>");
    QApplication a(argc, argv);
    CReadAndWrite w;
    w.show();

    return a.exec();

}

UI界面图

在这里插入图片描述

总结

以上就是代码的全部，其实只需要看主线程和第一个分线程就够了，后面都是重复的代码，多开线程就是为了提高处理的速度，中间涉及到的知识点不多，也都很好理解，看懂信号，连接，多线程也就会了。

束缚后解脱
关注
多线程代码实例
06-04
生产消费管理系统，采用多线程实现。在程序整个运行过程中，存在1个控制线程、1个生产者线程、以及若干个消费者线程。使用POSIX标准的互斥量、条件变量等进行共享资源的保护。
【并发编程】多线程先执行完的先取结果的解决方案：CompletionService
qq_35436158的博客
02-20 818
多线程一边生成任务,一边获取任务的返回值，让等待时间短的线程优先返回结果，这就是CompletionService。
C#中的多线程案例
愿你历尽千帆，归来仍是少年。
08-15 378
方法执行一些工作，并定期检查是否收到了取消请求。提供了一种优雅的方式来请求和响应取消操作，使异步编程更加灵活和健壮。，这个令牌可以被传递给异步操作，以便在需要时请求取消操作。是.NET中用于异步编程的一个类，它允许你创建一个。，然后将它传递给需要支持取消的异步操作。是否被触发，并在需要时处理取消逻辑。会发出取消请求，并且异步操作将捕获。作为参数传递给支持取消的异步方法。当你需要取消操作时，调用。
多线程编程10例
05-06 1006
进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。
多线程（十）多线程编程示例
HK的博客
11-27 2781
交替输出字符串、生产者消费者问题
多线程的代码案例（详解）
weixin_63018754的博客
04-24 1088
学习编程,需要必要的重复的。一个代码,反复写多遍,是非常正常的情况。如果细节很多,很难一次就把所有的细节都注意到都理解清楚。
java（简易）多线程HTTP服务器
06-09
一旦有连接请求到来，服务器就会创建一个新的Socket实例来处理这个连接，而这个过程可以通过多线程实现，以同时处理多个客户端请求。 对于GET和POST请求，它们是HTTP协议中最常见的两种请求方法。GET用于请求获取...
java多线程基于socket的简易聊天室源代码
06-04
在Java编程领域，多线程和Socket通信是两个重要的概念，它们在开发网络应用程序，特别是构建聊天室等实时交互系统时发挥着关键作用。在这个基于Java的简易聊天室源代码中，开发者通过巧妙地结合这两者，实现了客户端...
C++简易版游戏引擎开发与多线程应用实践
最新发布
09-26
内容概要：本文章介绍了一款用于练习C++编程技巧的简易游戏引擎的设计与实现，涉及模板编程、智能指针管理和多线程同步的知识点。文中提供了具体的代码实例来展示如何创建和更新游戏对象的位置以及进行游戏模拟运行...
GTK多线程聊天工具
07-10
总的来说，“GTK多线程聊天工具”是一个很好的实例，展示了如何结合GUI编程、网络通信和多线程技术来构建实时聊天应用。通过分析和学习该项目，开发者可以提升自己在这些领域的技能，并将所学应用到自己的项目中，...
简易聊天程序_java网络编程多线程
10-09
总结来说，"简易聊天程序_java网络编程多线程"项目涉及了Java网络编程的核心概念，包括`ServerSocket`和`Socket`的使用，多线程技术以实现并发处理，以及I/O流进行数据交换。通过这个项目，开发者可以深入理解如何在...
多线程经典代码案例及手动实现
LxinY213的博客
10-04 800
关于多线程编程的经典代码案例----单例模式,阻塞队列,定时器,线程池的分析及手动实现.
java学习笔记：多线程代码示例
黄道婆的专栏
07-08 360
Question: 编写多线程程序有几种实现方式？ 答：Java 5以前实现多线程有两种实现方法：一种是继承Thread类；另一种是实现Runnable 接口。两种方式都要通过重写run()方法来定义线程的行为，推荐使用后者，因为Java中的继承是 单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接 口更为灵活。 补充：Java 5以后创建线程还有第三种方式：实现Callable接口，该接口中的call方法可以在线 程执行结束时产生一个返回值。（展开知识，详见
Java多线程（附代码示例）
SimpleZihao的博客
10-08 1745
1. 一些概念 线程就是独立的执行路径 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程 main()称之为主线程，是系统的入口，用于执行整个程序 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制 线程会带来额外的开销，如cpu调度时间，并发控制开销 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致 2. 开启多线程的几种方式 1. 继承Thre
多线程的三种实现代码
yuxialuozi的博客
07-09 710
该类实现了Runnable接口，并重写了run()方法，在其中编写线程的任务逻辑。在上述代码中，我们定义了一个自定义线程类MyThread，该类继承了Thread类，并重写了Thread类的run()方法。需要注意的是，在多线程编程中，不要直接调用run()方法，而是通过start()方法来启动线程，因为直接调用run()方法只会在当前线程中以普通方法的方式执行，而不会启动一个新的线程。需要注意的是，在使用实现Runnable接口的方式时，线程的任务逻辑必须在run()方法中实现，而不是直接在类中编写。
多线程基础入门学习（带示例代码）
云泽的博客
04-23 1350
多线程基础入门学习概念并发与并行线程与进程创建线程的方法继承Thread类实现Runnable接口Thread与Runnable的区别线程的常用方法设置优先级(setPriority)休眠(sleep)设置让步(yield)合并(join)守护线程(setDaemon(true))线程的生命周期新建状态（New）就绪状态（Runnable）运行状态（Running）阻塞状态（Blocked）死亡状态（Dead）线程通信等待唤醒机制场景案例代码示例死锁 概念 并发与并行 并发：多个事件在同一时间段内发生；
Java多线程高并发，代码示例(一)
XIPIKER的博客
02-26 5794
对某个对象加锁 /** * synchronized关键字 * 对某个对象加锁 */ public class T { private int count = 10; private Object o = new Object(); public void m(){ //任何线程要执行下面代码，必须先拿到o锁 synchronized ...
多线程编程例子
Pop_Rain的博客
03-11 706
title: 多线程编程例子 date: 2019-10-1 19:00:08 updated: 2020-02-27 19:04:06 categories: 多线程 tags: - 多线程 本博文记录多线程编程的几个案例，包含了常见的几种多线程编程套路。 1.四个线程计算1到100的求和 1.依次调用thread.join()，主线程输出结果。注意：sum为共享变量，访问共享变量时，用s...
【多线程例子】c语言写一个多线程案例
yizhizainulii的博客
04-20 6876
第一个多线程程序 #include <stdio.h> #include <pthread.h> //定义线程要执行的函数，arg 为接收线程传递过来的数据 void *Thread1(void *arg) { printf("http://c.biancheng.net\n"); return "Thread1成功执行"; } //定义线程要执行的函数，arg 为接收线程传递过来的数据 void* Thread2(void* arg) { printf("C
DELPHI32中简易多线程数据库查询示例
在DELPHI32环境下进行多线程程序设计是一个重要的技能，尤其对于熟悉早期DOS和16位Windows编程的开发者来说，这是一个新的挑战。DELPHI2.0引入了方便的多线程编程特性，使得开发者无需深入复杂的WIN32 API，可以直接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值