C++ 使用QThread的多线程应用程序需要帮助吗

我是QThread的新手，我想用Qt制作一个多线程应用程序。有很多在线资源，一些人建议子类化QThread，一些人说这不是真的，他们使用moveToThread函数。我真的很困惑。也许这取决于需求，所以我正在写我的需求

软件将通过UDP协议与设备通信。设备将收到的数据包作为ACK发送回发送方。由于UDP不可靠，我想通过检查设备的答案来增加通信的可靠性。我想给设备一点时间来发送应答，如果应答（ACK数据包）没有出现，我想再次发送相同的数据包。如果出现错误的应答数据包（顺序错误的数据包），我可以忽略它，无需重新排序。将有一些数据包（用于设备的命令），这些数据包将定期发送，例如每秒

我想使用QThread在一个线程中进行所有通信。线程将通过单击按钮启动，通信将启动（一些数据包将定期发送）。单击按钮将停止通信

那我该怎么做呢？我只需要几步

编辑：

我已经实现了阻塞读写。我使用moveToThread函数将其移动到一个线程并启动该线程。但我不知道这是否是我的用例的最佳方式

我一个接一个地发送一些数据报，例如：

int UDP::readCalibration(..)
{
    while(readStatus() != 0);

    // Send addr, read page command and read buffer command
    // one after each
    writeRegisterBlock(LOW_ADDR, CalibAddr, 2); // Blocking
    writeRegister(CMD_Reg, READ_PAGE);          // Blocking
    readRegisterBlock(READ_BUF, data, 128);     // Blocking
}
....
int UDP::writeRegisterBlock(...) 
{
   ....// Build UdpPacket
   return UDP_Send(UdpPacket, &ReceivePacket);
}
int UDP::writeRegister(...) 
{
   ....// Build UdpPacket
   return UDP_Send(UdpPacket, &ReceivePacket);
}
int UDP::readRegisterBlock(...) 
{
   ....// Build UdpPacket
   return UDP_Send(UdpPacket, &ReceivePacket);
}
// and UDP_Send function, this is the important part
int UDP::UDP_Send(QByteArray UdpPacket, QByteArray *ReceivePacket)
{
    QByteArray Datagram;
    QHostAddress SenderAddress;
    quint16 SenderPort;
    int UDP_RetVal = -1, timeOutCounter = -1, NrOfSend = -1, NrOfRecv = -1, retVal = -1;
   bool pendingDatagram = false;

   SetContinueToRecv(true); // sets a boolean variable with mutex
   SetContinueToSend(true); // sets a boolean variable with mutex

   while ((NrOfSend < MAX_RETRY) && GetContinueToSend())
   {
       NrOfSend++;
       SetContinueToRecv(true); // start receiver loop
       UDP_RetVal = udpSocket->writeDatagram(UdpPacket, DestinationIP, port);

       if(UDP_RetVal < 0)
       {
           qDebug() << "udpSocket error";
       }
       else
       {
           while((NrOfRecv <  MAX_RETRY) && GetContinueToRecv())
           {
               pendingDatagram = false;

               while (!pendingDatagram && (timeOutCounter < TIMEOUT_MS))
               {
                   msleep(SLEEP_MS);
                   timeOutCounter++;
                   pendingDatagram = udpSocket->hasPendingDatagrams();
               }

               if (timeOutCounter < TIMEOUT_MS)
               {
                   Datagram.resize(udpSocket->pendingDatagramSize());
                   udpSocket->readDatagram(Datagram.data(), Datagram.size(), &SenderAddress, &SenderPort);

                   //Compare only first 4 bytes, cmd, nr, addr
                   if((UdpPacket.mid(0, 4) == Datagram.mid(0, 4)) && (SenderAddress == DestinationIP) )
                   {
                       retVal = 0;
                       //Take only data , not commands
                       ReceivePacket->resize(Datagram.size()-4);
                       ReceivePacket->replace(0, Datagram.size()-4, Datagram.right(Datagram.size()-4));
                       SetContinueToRecv(false); // Break receiver while loop
                       SetContinueToSend(false); // Break sender while loop
                   }
                   else // Wrong packet
                   {
                       SetContinueToRecv(true); // try again to receive
                       timeOutCounter = -1;
                       qDebug() << "Wrong Packet.";
                   }    // Wrong packet
               }
               else // Timeout
               {
                   qDebug() << "Timeout maximum. NrOfSend: " << NrOfSend << " NrOfRecv: " << NrOfRecv;
                   timeOutCounter = -1;
                   SetContinueToSend(true); // try again to send
                   SetContinueToRecv(false);
               }   // Timeout
           }  // Receive loop
           NrOfRecv = -1;
       }  // Succesfully sent
   }  // Send loop
   if(NrOfSend == MAX_RETRY)
   {
      retVal = -1; // Could not send.
      qDebug() << "Could not send";
   }
   return retVal;
}

intudp:：readCalibration（..）
{
while（readStatus（）！=0）；
//发送addr、读取页面命令和读取缓冲区命令
//一个接一个
writeRegisterBlock（LOW_ADDR，calibadr，2）；//阻塞
writeRegister（CMD_Reg，READ_PAGE）；//阻塞
readRegisterBlock（READ_BUF，data，128）；//阻塞
}
....
int UDP:：writeRegisterBlock（…）
{
..//Build UdpPacket
返回UDP_发送（UdpPacket和ReceivePacket）；
}
int UDP:：writeRegister（…）
{
..//Build UdpPacket
返回UDP_发送（UdpPacket和ReceivePacket）；
}
int UDP:：readRegisterBlock（…）
{
..//Build UdpPacket
返回UDP_发送（UdpPacket和ReceivePacket）；
}
//和UDP_发送函数，这是重要的部分
int UDP:：UDP_发送（QByteArray-UdpPacket，QByteArray*ReceivePacket）
{
QByteArray数据报；
QHostAddress发送者地址；
发送端口；
int UDP_RetVal=-1，timeOutCounter=-1，NrOfSend=-1，NrOfRecv=-1，RetVal=-1；
bool pendingDatagram=false；
SetContinueToRecv（true）；//设置具有互斥的布尔变量
SetContinueToSend（true）；//设置具有互斥的布尔变量
while（（NrOfSendwritedagram（UdpPacket，DestinationIP，port）；
如果（UDP_RetVal<0）
{
qDebug（）具有挂起的数据报（）；
}
if（超时计数器<超时\u MS）
{
resize（udpSocket->pendingDatagramSize（））；
udpSocket->readDatagram（Datagram.data（）、Datagram.size（）、&SenderAddress、&SenderPort）；
//仅比较前4个字节、cmd、nr、addr
if（（UdpPacket.mid（0，4）=数据报.mid（0，4））&&（SenderAddress==DestinationIP））
{
retVal=0；
//只获取数据，不获取命令
ReceivePacket->resize（Datagram.size（）-4）；
ReceivePacket->replace（0，Datagram.size（）-4，Datagram.right（Datagram.size（）-4））；
SetContinueToRecv（false）；//循环时中断接收器
SetContinueToSend（false）；//循环时中断发送器
}
else//错误的数据包
{
SetContinueToRecv（true）；//请重试接收
超时计数器=-1；
qDebug（）我强烈建议您使用该类为您的用例提供的异步API

使用一个连接到
readyRead（）
信号的插槽，并在该插槽中使用
readDatagram（）
从套接字实际读取接收到的数据。为了发送数据，可以使用
writeDatagram（）
任意位置，它不会阻塞调用线程

您可以读和写类似的代码

至于超时，您可以将一个带有
timeout（）
信号的连接到发送数据报的插槽，这样当在指定的时间内没有响应时，它发送数据报，并在连接到
readyRead（）
信号的插槽中调用计时器的
start（）
方法（以便每次接收到数据报时计时器重新启动）

为了回答您关于多线程的问题，一种简单使用它的常用方法是，拥有一个从
QObject
派生的类，并实现需要在该类中执行的插槽，然后实例化一个新的
QThread
并调用
moveToThread（）
将该对象上的插槽发送到新的
QThread
。之后，当连接到此对象插槽的任何信号发出时，插槽代码将在新线程中执行

然而，值得注意的是，在Qt中有许多方法可以利用多线程，每个用例都有自己的实现方法，请看这里。在您的用例中，根本不要使用多线程

编辑：
所以你不能上网，你实现了阻止读写

我使用moveToThread函数将其移动到一个线程并启动该线程

首先，您必须确保在将
QObject
移动到新线程后，您不会直接调用使用阻塞IO的函数，而是通过连接信号和