QThread中Unix域数据报Socket的recvfrom后信号无法接收问题

你的问题核心在于阻塞式系统调用recvfrom()卡住了QThread的事件循环：

• QThread的run()方法默认会启动事件循环，但你重写run()后在里面执行了阻塞的recvfrom()调用，直接占满了线程的执行流程。
• 首次发出的"before recvfrom"信号能被接收，是因为此时recvfrom()还未执行，线程事件循环还能正常处理信号发送逻辑。
• 一旦recvfrom()开始执行，它会完全阻塞线程，导致线程无法回到事件循环处理后续的信号队列，所以之后所有发出的信号都无法被主线程槽函数接收。
• 客户端能收到大写回复，是因为sendto()是同步调用，在recvfrom()返回后会立即执行，不需要依赖Qt的事件循环。

这里提供两种实用的修复思路，可根据需求选择：

方案1：改用Qt原生QUdpSocket实现Unix域数据报通信（推荐） #

Qt 5.8及以上版本支持QUdpSocket使用Unix域套接字，能完全利用Qt信号槽机制，避免阻塞调用：

1. 放弃继承QThread，创建普通QObject子类Worker，将其移动到独立线程中（这是Qt官方推荐的线程使用方式，比直接继承QThread更灵活）。
2. 在Worker类中初始化QUdpSocket，设置套接字类型为QAbstractSocket::UnixSocketType并绑定Unix域地址。
3. 连接QUdpSocket的readyRead()信号到Worker的槽函数，在槽函数中用readDatagram()读取数据，转大写后用writeDatagram()回复，同时发出progressChanged信号。
4. 将Worker对象移动到QThread实例中启动线程，确保事件循环正常运行。

核心代码片段：

// Worker类定义
class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr) {
        udpSocket = new QUdpSocket(this);
        udpSocket->setSocketOption(QAbstractSocket::SocketTypeOption, QAbstractSocket::UnixSocketType);
        // 绑定Unix域地址，示例路径为"/tmp/udpsocket"
        if (!udpSocket->bind(QHostAddress::LocalHost, 0, QUdpSocket::ShareAddress)) {
            qDebug() << "绑定失败:" << udpSocket->errorString();
        }
        connect(udpSocket, &QUdpSocket::readyRead, this, &Worker::handleDatagram);
    }

signals:
    void progressChanged(const QString &msg);

private slots:
    void handleDatagram() {
        while (udpSocket->hasPendingDatagrams()) {
            QByteArray datagram;
            datagram.resize(udpSocket->pendingDatagramSize());
            QHostAddress senderAddr;
            quint16 senderPort;
            udpSocket->readDatagram(datagram.data(), datagram.size(), &senderAddr, &senderPort);
            
            QString recvStr = QString::fromUtf8(datagram);
            emit progressChanged(recvStr); // 事件循环正常，信号可被处理
            
            // 转大写并回复
            QByteArray reply = recvStr.toUpper().toUtf8();
            udpSocket->writeDatagram(reply, senderAddr, senderPort);
        }
    }

private:
    QUdpSocket *udpSocket;
};

// 主线程中使用
QThread *workerThread = new QThread(this);
Worker *worker = new Worker();
worker->moveToThread(workerThread);
connect(workerThread, &QThread::started, [](){
    qDebug() << "工作线程启动";
});
connect(worker, &Worker::progressChanged, this, &MainWindow::onProgressChanged);
connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);
connect(workerThread, &QThread::finished, workerThread, &QObject::deleteLater);
workerThread->start();

方案2：保留原生socket，用QSocketNotifier避免阻塞 #

如果坚持使用原生Unix域数据报socket，可通过QSocketNotifier监听socket可读事件，替代阻塞的recvfrom()：

1. 在WorkerThread的run()方法中创建socket并绑定，设置socket为非阻塞模式。
2. 初始化QSocketNotifier，将socket可读事件关联到槽函数，启动线程事件循环（调用exec()）。
3. 在槽函数中调用非阻塞的recvfrom()处理数据，发送信号和回复。

核心代码片段：

// WorkerThread类run()方法
void WorkerThread::run() {
    int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        qDebug() << "创建socket失败";
        return;
    }

    struct sockaddr_un addr;
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, "/tmp/udpsocket", sizeof(addr.sun_path)-1);
    unlink(addr.sun_path); // 先删除旧套接字文件

    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        qDebug() << "绑定失败";
        close(sockfd);
        return;
    }

    // 设置socket为非阻塞模式
    int flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

    // 创建QSocketNotifier监听可读事件
    QSocketNotifier *notifier = new QSocketNotifier(sockfd, QSocketNotifier::Read, this);
    connect(notifier, &QSocketNotifier::activated, this, &WorkerThread::handleSocketRead);

    emit progressChanged("before recvfrom"); // 首次信号正常发送

    exec(); // 启动线程事件循环

    close(sockfd);
    unlink(addr.sun_path);
}

// 处理socket可读的槽函数
void WorkerThread::handleSocketRead(int sockfd) {
    char buf[1024];
    struct sockaddr_un clientAddr;
    socklen_t addrLen = sizeof(clientAddr);
    ssize_t recvLen = recvfrom(sockfd, buf, sizeof(buf)-1, 0, (struct sockaddr*)&clientAddr, &addrLen);
    if (recvLen > 0) {
        buf[recvLen] = '\0';
        QString recvStr = QString::fromUtf8(buf);
        emit progressChanged(recvStr); // 事件循环正常，信号可被处理

        // 转大写并回复
        QString upperStr = recvStr.toUpper();
        sendto(sockfd, upperStr.toUtf8().data(), upperStr.length(), 0, (struct sockaddr*)&clientAddr, addrLen);
    }

    emit progressChanged("before recvfrom"); // 后续信号正常发送
}

• Qt官方不推荐直接继承QThread实现多线程任务，更建议使用QObject + moveToThread模式，能更好地利用Qt事件循环机制。
• 阻塞式系统调用会破坏Qt线程的事件循环，导致信号槽、定时器等依赖事件循环的功能失效，这是问题的根本原因。

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