我的解决方案及其问题：

Question

我正在研究一个Qt应用程序，该应用程序涉及与一个或多个设备的串行通信。可以同时执行不同的过程，并且每个过程可以向设备发送一个或未知数量的命令，并可以作为响应接收数据。为了更加清楚，这是该方案的图形化图示：

单击按钮将触发相应过程的执行。因此，当用户在短时间内单击两个或多个按钮时，可能会同时运行两个或多个不同的过程。实际上，它们之间唯一可以共享的是与单个设备的串行通信。这是过程的外观的两个伪代码示例：

过程A：

begin
write command a1 on serial port
wait for one second
perform some computations
write command a2 on serial port
wait for one second
end

程序B：

begin
while true:
    write command b1 on serial port
    read the response from serial port
    perform some computations
    if a condition holds return, otherwise continue
end

我的解决方案及其问题：

为简化这种情况，请考虑只需要与一台设备进行通信。由于过程可以同时执行（并且一次只能有一个可以通过串行端口与设备通信），因此我为每个过程创建了一个线程和一个工作程序类，并将工作程序移到了相应的线程上。为了在访问串行端口时同步过程，我创建了一个互斥锁：

MainWindow.h

class MainWindow : public QMainWindow {

public:
    //...
    QSerialPort*    serial_;
    QMutex      serial_mutex_;

private:
    //...
    ProcAWorker*    proca_worker;
    ProcBWorker*    procb_worker;
    ProcCWorker*    procc_worker;
    ProcDWorker*    procd_worker;

    QThread     proca_thread;
    QThread     procb_thread;
    QThread     procc_thread;
    QThread     procd_thread;

}

MainWindow.cpp

void MainWindow::onConnectButtonClicked()
{
    serial_ = new QSerialPort();
    // configure serial port settings

    serial_->open(QIODevice::ReadWrite);
}

void MainWindow::onButtonAClicked()
{
    proca_worker = new ProcAWorker(0, this);   // pass a pointer to this class to be able to access its methods and members
    proca_worker->moveToThread(&proca_thread);

    // setup worker-thread connections: started, quit, finished, etc.

    proca_thread.start();    // triggers `proccess` slot in proca_worker
}

// same thing for other buttons and procedures

ProcAWorker.cpp

void ProcAWorker::ProcAWorker(QObject *parent, QMainWindow *wnd) :
    QObject(parent), wnd_(wnd)
{

}

void ProcAWorker::process()
{
    wnd_->serial_mutex_->lock();
    wnd_->serial_->write('Command a1');   // Warning occurs in this line
    bool write_ok = client_->serial_->waitForBytesWritten(SERIAL_WRITE_TIMEOUT);
    wnd_->serial_mutex_->unlock();

    QThread::sleep(1);
    // perform some computations

    wnd_->serial_mutex_->lock();
    wnd_->serial_->write('Command a2');
    bool write_ok = client_->serial_->waitForBytesWritten(SERIAL_WRITE_TIMEOUT);
    wnd_->serial_mutex_->unlock();

    if (write_ok) {
        // signal successful to main window
        emit success();
    }
}

但是，在串行端口（即wnd_->serial_->write('Command a1');）上执行写操作时，会显示以下警告：

QObject：无法为其他父母创建孩子线。（父母是QSerialPort（0x18907d0），父母的线程是 QThread（0x13cbc50），当前线程为QThread（0x17d8d08）

我的问题：

1）我已经查看了关于此警告的有关Stackoverflow的其他问题，但他们的回答仅提到应使用信号/插槽。我熟悉使用信号/插槽与工作线程进行通信。但是，我无法弄清楚如何使用信号/插槽实现我的特定方案（具有共享资源（如串行端口）的同时运行过程）或如何修改当前解决方案来解决此问题？请注意，应允许这些过程并行运行（除非它们想与设备进行通信的那一刻）。显然，一个人可以按顺序运行这些程序（即一个接一个地运行），但我不是在寻找这样的解决方案。

2）实际上，还有一个“暂停”按钮可以停止所有正在运行的过程，并向设备发送暂停命令。但是我也想不出要实现此功能（设置标志，发送退出信号等）。您能否在这方面也给我一些提示？

Answer 1

首先，您不需要显式多线程（它是可选的），其次，您不需要任何手动管理的同步原语。

然后，使用状态机为每个过程建模。希望通信协议允许每个过程识别对自己命令的响应，这样，即使将传入数据复制到所有过程中，它们也将忽略与它们无关的数据。

This answer给出了一种解决方案的示意图，该方案可以完全满足您的需求，没有多路复用。通过local pipes公开QIODevice时，它是微不足道的：从端口传入的所有内容都被写入一个或多个本地管道的一端。从管道传入的所有内容都将写入端口。只要您以Unbuffered模式打开管道的过程，管道就将保持分组的完整性。这样，每个write都会作为一个连续的字节块到达串行端口，并以相同的方式写入端口。

您将如何复用？像这样：

class IODeviceMux : public QObject {
  Q_OBJECT
  QVector<QPointer<AppPipe>> m_portPipes;
  QVector<QPointer<AppPipe>> m_userPipes;
  QPointer<QSerialPort> m_port;
public:
  IODeviceMux(QObject *parent = {}) : QObject(parent) {}
  void setPort(QIODevice *port) {
    if (m_port) {
      disconnect(m_port.get(), 0, this, 0);
      m_userPipes.removeAll({});
      for (auto pipe : qAsConst(m_userPipes))
        disconnect(m_port.get(), 0, pipe.get(), 0);
    }
    m_port = port;
    connect(m_port.get(), &QIODevice::readyRead, this, &IODeviceMux::onPortRead);
  }
  AppPipe *getPipe() {
    QScopedPointer<AppPipe> user(new AppPipe(QIODevice::ReadWrite | QIODevice::Unbuffered));
    auto *port = new AppPipe(QIODevice::ReadWrite | QIODevice::Unbuffered, this);
    user->addOther(port);
    connect(port, &QIODevice::readyRead, this, &IODeviceMux::onPipeRead);
    connect(m_port.get(), &QIODevice::bytesWritten, user.get(), &QIODevice::bytesWritten);
    connect(user, &QObject::destroyed, port, &QObject::deleteLater);
    m_userPipes.push_back(user.get());
    m_portPipes.push_back(port);
    return user.take();
  } 
private:
  void onPortRead() {
    if (!m_port) return;
    auto data = m_port->readAll();
    m_portPipes.removeAll({});
    for (auto pipe : qAsConst(m_portPipes))
      pipe->write(data);
  }
  void onPipeRead() {
    auto *pipe = qobject_cast<AppPipe*>(sender());
    QByteArray data;
    if (pipe) data = pipe->readAll();
    if (m_port) m_port->write(data);
  }
};

每个过程将getPipe()对待管道，就好像它是一个串行端口设备一样。管道中的每个write都会在端口上忠实执行。端口上的每个readyRead都会如实转发，并具有立即读取的相同数据量。甚至端口的bytesWritten也被转发。但是bytesToWrite不起作用-它总是返回零。可以通过在AppPipe中添加一个选项来查询此值来解决此问题。

我想，这就是使它正常工作所需的一切。

Qt应用程序中具有共享资源的辅助线程

我的解决方案及其问题：

1 个答案: