Qt多线程TCP服务器客户端传输文件

已于 2023-01-04 14:46:47 修改
阅读量4.5k 收藏 103
点赞数 10
分类专栏： Qt 文章标签： tcp/ip qt tcp
于 2023-01-04 14:45:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_iostream/article/details/128531354
版权

文章目录

TCP的理论知识

TCP的特点：

  1. TCP是面向连接的运输层协议。应用程序在使用TCP协议之前，必须先建立TCP连接。在传送数据完毕后，必须释放已经建立的TCP连接。
  2. 每一条TCP连接只能有两个端点，每一条TCP连接只能是点对点的(一对一)。
  3. TCP提供可靠交付的服务。通过TCP 连接传送的数据，无差错、不丢失、不重复，并且按序到达。
  4. TCP提供全双工通信。TCP允许通信双方的应用进程在任何时候都能发送数据。TCP连接的两端都设有发送缓存和接受缓存，用来临时存放双向通信的数据。
  5. 面向字节流。TCP中的"流"指的是流入到进程或从进程流出的字节序列。

满足这些特点的规定

  1. 数据分片：在发送端对用户数据进行分片，在接收端进行重组，由TCP确定分片的大小并控制分片和重组；
  2. 到达确认：接收端接收到分片数据时，根据分片数据序号向发送端发送一个确认；
  3. 超时重发：发送方在发送分片时启动超时定时器，如果在定时器超时之后没有收到相应的确认，重发分片；
  4. 滑动窗口：TCP连接每一方的接收缓冲空间大小都固定，接收端只允许另一端发送接收端缓冲区所能接纳的数据，TCP在滑动窗口的基础上提供流量控制，防止较快主机致使较慢主机的缓冲区溢出；
  5. 失序处理：作为IP数据报来传输的TCP分片到达时可能会失序，TCP将对收到的数据进行重新排序，将收到的数据以正确的顺序交给应用层；
  6. 重复处理：作为IP数据报来传输的TCP分片会发生重复，TCP的接收端必须丢弃重复的数据；
  7. 数据校验：TCP将保持它首部和数据的检验和，这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如果收到分片的检验和有差错，TCP将丢弃这个分片，并不确认收到此报文段导致对端超时并重发。

多线程的知识点

多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”[1]

优点

  1. 使用线程可以把占据时间长的程序中的任务放到后台去处理 [2]
  2. 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度 [2]
  3. 程序的运行速度可能加快 [2]
  4. 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等 [2]
  5. 多线程技术在IOS软件开发中也有举足轻重的作用 [2]

缺点

  1. 如果有大量的线程，会影响性能，因为操作系统需要在它们之间切换 [2]
  2. 更多的线程需要更多的内存空间 [2]
  3. 线程可能会给程序带来更多“bug”，因此要小心使用 [2]
  4. 线程的中止需要考虑其对程序运行的影响 [2]
  5. 通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生 [2]

创建工程

需要在工程文件pro中添加network库

QT       += core gui network

要使用lambda函数的话还需在工程文件在加入

CONFIG += C++11

TCP服务器

创建一个工作类继承QObject类

接收文件的.h文件

#ifndef RECVFILE_H
#define RECVFILE_H

#include <QObject>
#include <QTcpSocket>
#include <QTcpServer>
#include <QFile>

class RecvFile : public QObject
{
    Q_OBJECT
public:
    explicit RecvFile(QObject *parent = nullptr);
    //接收文件函数
    void recvFile();
    //启动监听
    void startListen(unsigned short port);

signals:
    //接收完毕
    void recvOver();
    //通知主线程发送文件进度百分比
    void curPercent(int num);

public slots:

private:
    QTcpServer *tcpServer;//监听套接字
    QTcpSocket *tcpSocket;

    QFile file;
    QString filename;//文件名称
    qint16 filesize;//文件大小

    qint16 recvfilesize;//已接收大小
    bool isStart;//接收头部标记
};

#endif // RECVFILE_H

接收文件的.cpp文件

#include "recvfile.h"
#include <QFile>
#include <QDebug>

RecvFile::RecvFile(QObject *parent) : QObject(parent)
{

}
void RecvFile::startListen(unsigned short port)
{
    qDebug()<<port;
    //分配内存空间
    tcpServer = new QTcpServer(this);
    tcpServer->listen(QHostAddress::Any,port);
    connect(tcpServer,&QTcpServer::newConnection,[=]()
    {
        //取出建立好连接的套接字
        tcpSocket = tcpServer->nextPendingConnection();

        isStart = true;
        connect(tcpSocket,&QTcpSocket::readyRead,this,&RecvFile::recvFile);
        connect(tcpSocket,&QTcpSocket::disconnected,this,[=]()
        {
            //断开连接
            tcpSocket->close();
            tcpSocket->deleteLater();
            emit recvOver();

        });
    });
}

void RecvFile::recvFile()
{
    //取出接收的内容
    QByteArray buf = tcpSocket->readAll();
    if(true == isStart)
    {
        //接收头部
        isStart = false;
        //解析头部
        filename = QString(buf).section("##",0,0);
        filesize = QString(buf).section("##",1,1).toInt();
        recvfilesize = 0;
        //打开文件
        file.setFileName(filename);
        bool isOk = file.open(QIODevice::WriteOnly);
        if(false == isOk)
        {
            return;
        }
    }
    else
    {
        qint64 len = file.write(buf);
        if(len>0)
        {
            recvfilesize += len;//累计接收大小
            int percent = (static_cast<int>(recvfilesize)*100)/filesize;
            //发出更新进度条的信号
            emit curPercent(percent);
        }

        if(recvfilesize == filesize)
        {
            file.close();
            isStart = true;
        }
    }
}

主窗口的.h文件

#ifndef MYWIDGET_H
#define MYWIDGET_H

#include <QWidget>
#include<QTcpServer>

namespace Ui {
class MyWidget;
}

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    explicit MyWidget(QWidget *parent = 0);
    ~MyWidget();
signals:
    void startListen(unsigned short);

private slots:
    void on_buttonlisten_clicked();

private:
    Ui::MyWidget *ui;
    QTcpServer *tcpServer;
};

#endif // MYWIDGET_H

主窗口的.cpp文件

#include "mywidget.h"
#include "ui_mywidget.h"
#include <QThread>
#include <QMessageBox>
#include <QFileDialog>
#include "recvfile.h"

MyWidget::MyWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MyWidget)
{
    ui->setupUi(this);
    //设置进度条
    ui->progressBar->setRange(0,100);
    ui->progressBar->setValue(0);
    //创建线程对象
    QThread *thread = new QThread;
    //创建任务对象
    RecvFile *recvWork = new RecvFile;
    //将任务对象移到子线程中
    recvWork->moveToThread(thread);

    connect(this,&MyWidget::startListen,recvWork,&RecvFile::startListen);
    //更新进度条
    connect(recvWork,&RecvFile::curPercent,ui->progressBar,&QProgressBar::setValue);
    //启动线程
    thread->start();

}

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

void MyWidget::on_buttonlisten_clicked()
{
    //获取端口
    unsigned short port = ui->lineEdport->text().toUShort();
    //发出连接信号
    emit startListen(port);
}

TCP客户端

发送文件的.h文件

#ifndef SENDFILE_H
#define SENDFILE_H

#include <QObject>
#include <QTcpSocket>
#include <QFile>
#include <QTimer>

class SendFile : public QObject
{
    Q_OBJECT
public:
    explicit SendFile(QObject *parent = nullptr);

    //连接服务器
    void connectServer(unsigned short port,QString ip);
    //发送文件
    void sendfile(QString path);
protected:
    //发送文件数据
    void sendfileData();

signals:
    //通知主线程连接成功
    void connectOK();
    //通知主线程断开连接
    void gameover();
    //通知主线程发送文件进度百分比
    void curPercent(int num);

public slots:

private:
    QTcpSocket *tcpSocket;

    QFile file;//文件对象
    QString filename;//文件名字
    qint16 filesize;//文件大小
    qint16 sendfilesize;//已发送大小

    QTimer *timer;

};

#endif // SENDFILE_H

发送文件的.cpp文件，利用一个QTimer对象做一个延时20ms，防止黏包问题，先创建一个头部信息，包含文件名和文件大小，让接收端先接收头部信息，20ms后再接收数据部分。

#include "sendfile.h"
#include <QFile>
#include <QHostAddress>
#include <QFileInfo>
#include <QTimer>
#include <QDebug>
SendFile::SendFile(QObject *parent) : QObject(parent)
{

}

//连接服务器
void SendFile::connectServer(unsigned short port, QString ip)
{
    //分配内存空间
    tcpSocket = new QTcpSocket;
    //连接服务器
    tcpSocket->connectToHost(QHostAddress(ip),port);

    //通知主线程连接成功
    connect(tcpSocket,&QTcpSocket::connected,this,&SendFile::connectOK);

    //通知主线程断开连接
    connect(tcpSocket,&QTcpSocket::disconnected,this,[=]()
    {
        //断开连接，释放资源
        tcpSocket->close();
        tcpSocket->deleteLater();
        emit gameover();
    });
    timer = new QTimer(this);
    connect(timer,&QTimer::timeout,[=]()
    {
        //关闭定时器
        timer->stop();
        //发送文件数据
        sendfileData();
    });
}

//发送文件
void SendFile::sendfile(QString path)
{
    file.setFileName(path);
    //获取文件信息
    QFileInfo info(path);
    filesize = info.size();//获取文件大小
    filename = info.fileName();//获取文件名
    //只读方式打开文件
    bool isOk = file.open(QIODevice::ReadOnly);
    if(true == isOk)
    {
        //创建文件头信息
        QString head = QString("%1##%2").arg(filename).arg(filesize);
        //发送头部信息
        qint64 len = tcpSocket->write(head.toUtf8());
        if(len>0)
        {
            //防止tcp黏包问题,延时20ms
            timer->start(20);
        }
        else
        {
            //发送失败
            file.close();
        }

    }
    else
    {
        return;
    }

}

void SendFile::sendfileData()
{
    qint64 len = 0;
    //读多少发多少
    do
    {
        //每次发送的大小
        char buf[4*1024] = {0};
        //记录每行数据
        len = file.read(buf,sizeof(buf));
        //计算百分比，发给主线程
        sendfilesize += len;
        int percent = (static_cast<int>(sendfilesize)*100)/filesize;
        //发出更新进度条的信号
        emit curPercent(percent);
        //发送数据
        tcpSocket->write(buf,len);
    }while(len>0);

    if(sendfilesize == filesize)
    {
        file.close();
        filename.clear();
        filesize = 0;
    }
}

主窗口的.h文件

#ifndef MYWIDGET_H
#define MYWIDGET_H

#include <QWidget>

namespace Ui {
class MyWidget;
}

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    explicit MyWidget(QWidget *parent = 0);
    ~MyWidget();
signals:
    //连接信号
    void startConnect(unsigned short,QString);
    //发送文件信号
    void sendFile(QString path);
private slots:
    void on_bConnect_clicked();

    void on_bSelectFile_clicked();

    void on_bSend_clicked();

private:
    Ui::MyWidget *ui;
};

#endif // MYWIDGET_H

主窗口的.cpp文件

#include "mywidget.h"
#include "ui_mywidget.h"
#include <QThread>
#include <QMessageBox>
#include <QFileDialog>
#include "sendfile.h"

MyWidget::MyWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MyWidget)
{
    ui->setupUi(this);
    //设置ip和端口
    ui->lineEdIP->setText("127.0.0.1");
    ui->lineEdPort->setText("8888");
    //设置进度条
    ui->progressBar->setRange(0,100);
    ui->progressBar->setValue(0);

    //创建线程对象
    QThread *thread = new QThread;
    //创建任务对象
    SendFile *sendWork = new SendFile;
    //将任务对象移到子线程中
    sendWork->moveToThread(thread);
    //当发送sendFile信号时，让任务对象启动发文件处理函数
    connect(this,&MyWidget::sendFile,sendWork,&SendFile::sendfile);
    //通过信号让任务对象连接服务器
    connect(this,&MyWidget::startConnect,sendWork,&SendFile::connectServer);
    //处理连接成功的信号，弹出连接成功的提示
    connect(sendWork,&SendFile::connectOK,this,[=]()
    {
        QMessageBox::information(this,"连接服务器","成功连接了服务器。");
    });
    //断开连接
    connect(sendWork,&SendFile::gameover,this,[=]()
    {
        //释放资源
        thread->quit();
        thread->wait();
        sendWork->deleteLater();
        thread->deleteLater();
    });
    //更新进度条
    connect(sendWork,&SendFile::curPercent,ui->progressBar,&QProgressBar::setValue);
    //启动线程
    thread->start();

}

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

void MyWidget::on_bConnect_clicked()
{
    //获取ip和端口
    QString ip = ui->lineEdIP->text();
    unsigned short port = ui->lineEdPort->text().toUShort();
    //发出连接信号
    emit startConnect(port,ip);
}

void MyWidget::on_bSelectFile_clicked()
{
    QString path = QFileDialog::getOpenFileName();
    //判断路径是否为空
    if(path.isEmpty())
    {
        QMessageBox::warning(this,"打开文件","选择路径不能为空");
        return;
    }
    //将路径显示在文本栏中
    ui->lineEdfilePath->setText(path);
}

void MyWidget::on_bSend_clicked()
{
    //发送文件
    emit sendFile(ui->lineEdfilePath->text());

}

界面布局

发送端界面
发送端界面
接收端界面
接收端界面
项目结构
项目结构

总结

这个简易的文件传输，发送端和接收端都是将数据处理部分放在了子线程，主线程只负责界面的更新和部分信号的发送，子线程处理完数据后发出信号告知主线程，让主线程做出相对应的处理，子线程通过继承QObject类的方式，利用信号与槽的方式进行启动子线程处理函数。

谢箭，何小群,LABVIEW实用程序设计,西南交通大学出版社,2017.07,第125页
胡璞编著,体育装备嵌入式技术,中国地质大学出版社,2014.09,第259页

开发借鉴 Qt实现基于多线程的文件传输(服务端，客户端)

L-iostream
关注
  • 10
    点赞
  • 踩
  • 103
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
QT多线程实现基于TCP的文件传输功能
Kobayashiqaq的博客
10-22 842
QT中多线程的两种使用方式：1、继承QThread类并重写run()函数。2、使用moveToThread()函数将QObject派生类移动到新的线程中执行。
QT实现TCP服务器多线程编程.zip
06-11
在QT环境，实现了TCP Server服务器，支持多线程，代码简单明了，易于学习实现，分别继承QTcpServer和QTcpScoket实现出自己需要的类。 继承QTcpServer为每个客户端连接时分配线程，并接受处理tcpScoket的信号和槽、、还有发送信息，储存连接信息等。 继承QTcpScoket为处理通信数据和增加信号的参数，以便和tcpServer更好的配合。
Qt实现简易的多线程TCP服务器（附源码）
z1zyy的博客
03-25 1064
1.首先我们搞清楚，这个类是负责干嘛的？这个类我们要继承QTcpServer，重写虚函数incomingConnetion2.这是头文件，如果有报错，注意看使用#pragma once没有，因为可能涉及到头文件重复包含Q_OBJECTpublic:private://重写虚函数private://用来保存连接进来的套接字，存到ComboBox中//再包含一个widget对象//widget.hQ_OBJECTpublic:~Widget();
QT多线程TCP服务器客户端通讯程序
06-05
在QT网络编程中，服务器往往需要和多个客户端保持连接，因此，我在熟悉多线程编程过程中，在TCP服务每接收到一个客户端连接请求，就新建一个线程。客户端也是在新建的线程中维护的。 程序的思路如下： 程序使用了非模式对话框来分别显示服务器和客户端，默认情况下客户端使用127.0.0.1这个本地IP来和自己进程内的服务器通讯。服务器在监听到新客户端的连接请求后新建对话框以及一个线程与客户端通讯，客户端建立连接成功后会将自己的线程ID发送给服务器，服务器接收到数据后将自己的线程ID返回给客户端。客户端断开连接后会自动将对话框关闭以及释放资源。服务器端在客户端断开后，也会自动将对话框关闭。
QT之TCP传输客户端和服务器端互发信息的实现
04-08
TCP传输的QT程序，包括客户端和服务器端，具体功能： 1）客户端和服务器的连接； 2）客户端往服务器发送输入的需要发送的信息，在服务器的接收显示界面显示； 3）服务器往客户端发送输入的需要发送的信息，在客户端的接收界面显示； 4）断开连接功能，点击断开按钮实现服务器与客户端断开连接，断开之后就不能再进行传输，再次传输需要重新连接； 客户端包括： 1）服务器IP地址输入框； 2）端口号输入框； 3）连接功能键； 4）接收信息显示区； 5）发送信息输入区； 6）发送 功能键； 7）断开连接功能键； 服务器端包括： 1）接收信息显示区； 2）发送信息输入区； 3）发送 功能键； 4）断开连接功能键； 下载可以直接使用QT运行
QT TCP多线程编程例子
06-06
这是QT TCP多线程编程的例子，开启多个客户端可以从服务器中取得不同的数据。
Qt详解实现TCP文件传输例子（文件下载和上传）附源码
qq_44667165的博客
06-11 9851
变量qint64 payloadSize用来控制每次文件读取的字节数，progressByte用来存储发送的进度，我这里一次只发送1024个字节，因为区域网传输太快了，文明小传输过程不明显，你们可以调大小，比如1024*64个字节。收到服务器发送的文件信息消息后，进行读取，获取文件名，文件大小，用文件类对象进行存储，新建准备写入一个要下载的文件，准备工作完成后，向服务器发送获取文件数据的消息。传输文件信息时，需要获取要发送的文件信息，如文件名，文件大小等，然后将这些信息发送给客户端。//是否正在下载标识。
在QT中利用TCP协议实现多线程的传输文件
qdeeafafasaa的博客
06-09 6605
本文在QT中利用TCP协议实现了一个多线程的文件互传系统
QT通过TCP协议传输文件
weixin_43473965的博客
06-17 2131
常用的网络协议分为TCP和UDP两种，两种方式各有优缺点，其中TCP的主要特点是可靠，但是速度较慢（不丢包）；而UDP则是不可靠传输，但速度快（可能丢包）。今天主要介绍的就是通过QT框架和TCP协议实现简单的文件传输。
基于Qt的多线程TCP即时通讯软件的设计与实现
SWULWJ的博客
05-17 7919
基于Qt的多线程TCP即时通讯软件的设计与实现 本文将从涉及到主要技术开始，讲解使用Qt来实现一个支持多客户端链接的多线程TCP服务器及其客户端的设计与实现的解决方案。 注：本文使用的开发环境为Qt5.15.2,使用MSVC2019_64编译器,C++11及以上
QT-TCP服务端开启多个线程处理收到多客户端发来的消息示例
ligare的博客
02-17 7894
一些用到的函数等解释: void incomingConnection ( int socketDescriptor ) 当有新连接可用时，QTcpServer将调用此虚拟函数。注意：如果希望将传入连接作为另一个线程中的新QTcpSocket对象处理，则必须将socketDescriptor传递给另一个线程，在那里创建QTcpSocket对象并使用其setSocketDescriptor()方法。 ...
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
08-11
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
Qt编写的多线程局域网通信软件（含文件传输）
01-23
编写环境是VS2010和Qt4.8.5，工程分为客户端和服务器端，可以实现局域网的通信，涉及到TCP、UDP、多线程、文件传输等知识
Qt实现的文件传输和对话
02-29
Qt实现的文件传输和客户端和服务器端的对话，使用TCP协议，使用多线程 Qt实现的文件传输和客户端和服务器端的对话，使用TCP协议，使用多线程
基于Qt的多线程流水线异步服务器稳定版
06-07
数据库被作为资源管理，支持在多线程的条件下，使用数据库资源。 5、 框架界面。尽管常见的服务运行时表现为一个后台进程，但为了更好的演示服务器的功能，避免繁琐的配置，还是需要一个图形界面来显示状态、设置...
TCP相关问题总结
qq_62835094的博客
04-23 1218
假设TCP是两次握手，则可能会发生以下情况客户端发起TCP握手，向服务器发送SYN，但该数据因网络波动滞留此时触发超时重传，重新简历TCP连接当新建立的连接断开后，之前在网络中滞留的SYN连接请求传递到服务端，服务端误以为客户端需要建立TCP连接，因此会发送SYN+ACK请求，并进入连接建立状态，但客户端并不需要建立连接，不会发送数据，因此会造成服务端资源的浪费三次握手可以防止客户端无效连接信息再次到达服务器，导致重新连接之所以需要四次挥手，因为半关闭tcp通道允许双方互相发送数据，数据是双向流动的。
TCP/IP协议（二）
借风拥你
04-22 1202
TCP滑动窗口是TCP协议中的一种流量控制机制，用于调节发送方和接收方之间的数据传输速率，以避免网络拥塞和提高传输效率。滑动窗口机制允许发送方在不等待确认应答的情况下连续发送多个数据段。
IP归属地在互联网行业中的应用
最新发布
m0_73834612的博客
04-26 534
在电子商务和金融领域，IP归属地也被用于反欺诈和风险控制。例如，如果用户的登录IP地址突然发生跨国或异常变化，系统可能会触发风险提示，要求进行额外的身份验证，以防止欺诈行为的发生。通过分析用户的IP地址，服务提供商可以快速确定用户所在的地理位置，从而提供更贴近用户需求的服务和产品。通过分析恶意IP地址的地理位置信息，安全专家可以迅速定位攻击源，并采取相应的防御措施，保护系统和数据的安全。随着技术的不断进步和数据分析能力的提升，IP归属地将发挥越来越重要的作用，为互联网行业的发展和用户体验提供更多可能性。
WSL2无法ping通本地主机ip的解决办法
人工智能
04-23 479
WSL2无法ping通本地主机ip的解决办法: 刚装完WSL2的Ubuntu子系统时，可能无法ping通本地主机的ip ping通了，完美解决！
qt多线程tcp文件传输
06-11
在Qt中使用多线程进行TCP文件传输可以分为以下几个步骤： 1. 创建一个TCP服务器和一个TCP客户端。 2. 在TCP服务器中，为每个连接创建一个线程，并在该线程中处理文件的传输。 3. 在TCP客户端中，创建一个线程，该线程负责发送文件给服务器。 4. 在服务器和客户端之间建立连接后，客户端将文件发送到服务器。 5. 服务器收到文件后，在相应的线程中将文件保存到本地。 下面是一个简单的示例代码，可以供您参考： 1. TCP服务器端代码： ``` void Server::startServer() { tcpServer = new QTcpServer(this); connect(tcpServer, SIGNAL(newConnection()), this, SLOT(newConnection())); if (!tcpServer->listen(QHostAddress::Any, 12345)) { qDebug() << "Unable to start the server: " << tcpServer->errorString(); return; } qDebug() << "Server is running on port " << tcpServer->serverPort(); } void Server::newConnection() { QTcpSocket* clientSocket = tcpServer->nextPendingConnection(); ServerThread* thread = new ServerThread(clientSocket, this); connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); thread->start(); } ``` 2. TCP服务器端线程代码： ``` ServerThread::ServerThread(qintptr socketDescriptor, QObject *parent) : QThread(parent), socketDescriptor(socketDescriptor) { } void ServerThread::run() { QTcpSocket tcpSocket; if (!tcpSocket.setSocketDescriptor(socketDescriptor)) { return; } QFile file("/path/to/save/file"); if (!file.open(QIODevice::WriteOnly)) { return; } QByteArray buffer; while (tcpSocket.bytesAvailable() > 0) { buffer = tcpSocket.read(1024); file.write(buffer); } file.close(); } ``` 3. TCP客户端代码： ``` void Client::sendFile(QString filePath) { QThread* thread = new QThread(); ClientWorker* worker = new ClientWorker(filePath); worker->moveToThread(thread); connect(thread, SIGNAL(started()), worker, SLOT(sendFile())); connect(worker, SIGNAL(finished()), thread, SLOT(quit())); connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater())); connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); thread->start(); } ``` 4. TCP客户端线程代码： ``` ClientWorker::ClientWorker(QString filePath) : filePath(filePath) { } void ClientWorker::sendFile() { QTcpSocket tcpSocket; tcpSocket.connectToHost("127.0.0.1", 12345); if (!tcpSocket.waitForConnected()) { return; } QFile file(filePath); if (!file.open(QIODevice::ReadOnly)) { return; } QByteArray buffer; while (!file.atEnd()) { buffer = file.read(1024); tcpSocket.write(buffer); } file.close(); } ``` 请注意，这只是一个简单的示例代码，您需要根据您的实际需求进行修改和优化。同时，确保您的代码具有足够的安全性和可靠性，以避免数据丢失和安全问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值