QSerialPort在QThread中阻塞原因咨询

Ah, I see the issue here—this is a common pitfall when mixing Qt's serial port handling with threads. Let's break down why your serial port is blocking and how to fix it properly:

Why You're Seeing Blocking #

• QSerialPort isn't thread-safe: Like most Qt QObject subclasses, QSerialPort is designed to be used entirely within a single thread. When you create it in the main thread but call readAll() from a child thread, you're messing with its internal state (like read buffers and hardware control signals) from two different threads at once. This causes race conditions, corrupted data, and eventually the port gets stuck because its internal logic can't handle the concurrent access.
• Thread affinity mismatch: Every QObject is tied to the thread it was created in. When you connect readyRead to a slot in your child thread, the slot runs in the child thread—but calling m_serial->readAll() from there is a direct cross-thread call to the port object that lives in the main thread. Qt doesn't protect against this for non-thread-safe classes, so things go off the rails over time.

Fixes to Try #

You have two solid options depending on your needs:

Option 1: Move the entire serial port to the child thread

This is the cleanest approach because it keeps all serial operations in one thread:

1. Create your QSerialPort without a parent (so it can be moved between threads).
2. Use moveToThread() to shift it to your child thread.
3. Connect the child thread's started() signal to a slot that opens and configures the port—this slot will run in the child thread, so the port is initialized in the right context.
4. Connect readyRead to a slot in the same child thread to read and process data safely.

Here's a quick code example:

// In your main thread setup
QThread* serialThread = new QThread(this);
QSerialPort* m_serial = new QSerialPort(); // No parent, critical for moving

// Move the port to the child thread
m_serial->moveToThread(serialThread);

// Connect signals to handle port setup and data reading
connect(serialThread, &QThread::started, this, [m_serial]() {
    m_serial->setPortName("COM3");
    m_serial->setBaudRate(QSerialPort::Baud9600);
    if (!m_serial->open(QIODevice::ReadOnly)) {
        qDebug() << "Failed to open serial port!";
    }
});

// This slot runs in the child thread, so readAll() is safe
connect(m_serial, &QSerialPort::readyRead, this, [m_serial]() {
    QByteArray message = m_serial->readAll();
    qDebug() << message;
}, Qt::DirectConnection);

// Start the thread
serialThread->start();

Option 2: Keep the port in the main thread, pass data to the child thread

If you need the port to stay in the main thread, handle the readyRead signal there, then send the data to the child thread for processing:

1. In the main thread, connect readyRead to a slot that reads the data with readAll().
2. Emit a custom signal from this slot carrying the QByteArray data.
3. Connect this custom signal to a slot in your child thread—Qt will safely queue the data between threads.
4. The child thread's slot can print or process the data without ever touching the QSerialPort object.

Example code snippet:

// Main thread class (header)
class MainApp : public QObject {
    Q_OBJECT
signals:
    void newSerialData(QByteArray data);
private slots:
    void handleReadyRead() {
        QByteArray message = m_serial->readAll();
        emit newSerialData(message);
    }
};

// Child thread processor class
class DataLogger : public QObject {
    Q_OBJECT
public slots:
    void logSerialData(QByteArray data) {
        qDebug() << data;
    }
};

// Setup in main thread
DataLogger* logger = new DataLogger();
QThread* loggerThread = new QThread(this);
logger->moveToThread(loggerThread);
loggerThread->start();

MainApp* mainApp = new MainApp();
connect(m_serial, &QSerialPort::readyRead, mainApp, &MainApp::handleReadyRead);
connect(mainApp, &MainApp::newSerialData, logger, &DataLogger::logSerialData, Qt::QueuedConnection);

Quick Reminder #

• Never call methods on a QSerialPort from a thread other than the one it belongs to (created in or moved to).
• All serial operations—opening, reading, writing, changing settings—must happen in the same thread to avoid state corruption and blocking.

内容的提问来源于stack exchange，提问作者Aakankshakate