PyQt5 Socket服务器运行时冻结崩溃问题求助

问题描述 #

编写了一个具备Socket端口监听功能的PyQt窗口，客户端向该服务器发送数据。单独运行UI功能正常，但配置Socket后，程序显示UI、打印‘server binded’和‘starting update data’后即冻结并崩溃，部署在树莓派4上。

用户提供的代码：

import time
import socket
from PyQT5.QTCore import QTimer

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        
        self.initUI()

    def initUI(self):

        ... UI stuff
        
        self.initSocket()
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.updateData)
        self.timer.start(1000)

    def initSocket(self):
        binded = False
        while True:
            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            if not binded:
                try:
                    self.socket.bind(('localhost', 12345))
                    self.socket.listen(5)
                    binded = True
                    print("server binded")
                    break
                except Exception as e:
                    print(f"Error binding: {e}")
                    time.sleep(1)
 
    def updateData(self):
        print("starting update data")
        try:
            conn, addr = self.socket.accept()
            print("accepted connection from client")
            data = self.socket.recv(1024).decode()
            data_dict = json.loads(data)
        except Exception as e:
            print(f"Error updating data: {e}")

问题根源 #

• 阻塞式Socket操作卡死UI线程：socket.accept()和socket.recv()是阻塞方法，无客户端连接/数据时会一直占用主线程，而PyQt的UI渲染、事件循环都依赖主线程，一旦阻塞就会导致UI冻结崩溃。
• 主线程中使用time.sleep：initSocket里的time.sleep(1)会直接阻塞UI初始化流程，引发卡顿。
• Socket调用错误：updateData里用self.socket.recv()是错误的，应该使用accept()返回的conn套接字进行数据接收。
• 缺失依赖导入：代码使用json.loads但未导入json模块。

修复方案 #

将Socket的监听、数据接收逻辑放到独立子线程中，彻底避免阻塞主线程，同时修正Socket使用错误。

修复后的代码 #

import json
import socket
from PyQt5.QtCore import QTimer, QThread, pyqtSignal
from PyQt5.QtWidgets import QMainWindow

class SocketServerThread(QThread):
    # 定义信号，用于向主线程传递数据和错误信息
    data_received = pyqtSignal(dict)
    error_occurred = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.running = True
        self.socket = None

    def run(self):
        # 子线程内初始化Socket并绑定端口
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.settimeout(1)  # 设置超时，避免永久阻塞
        binded = False
        while self.running and not binded:
            try:
                self.socket.bind(('localhost', 12345))
                self.socket.listen(5)
                binded = True
                print("server binded")
            except Exception as e:
                err_msg = f"Error binding: {e}"
                self.error_occurred.emit(err_msg)
                QThread.msleep(1000)  # 子线程专用休眠，不影响主线程
        
        # 循环监听客户端连接
        while self.running and binded:
            try:
                conn, addr = self.socket.accept()
                print(f"accepted connection from {addr}")
                conn.settimeout(5)
                data = conn.recv(1024).decode()
                if data:
                    data_dict = json.loads(data)
                    self.data_received.emit(data_dict)
                conn.close()
            except socket.timeout:
                continue  # 超时后继续循环监听
            except Exception as e:
                err_msg = f"Error receiving data: {e}"
                self.error_occurred.emit(err_msg)
        
        # 清理Socket资源
        if self.socket:
            self.socket.close()

    def stop(self):
        self.running = False
        self.wait()

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
        self.initSocketThread()

    def initUI(self):
        # ... 你的UI初始化代码
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.updateUI)
        self.timer.start(1000)

    def initSocketThread(self):
        # 创建并启动Socket子线程
        self.socket_thread = SocketServerThread()
        self.socket_thread.data_received.connect(self.handleReceivedData)
        self.socket_thread.error_occurred.connect(self.handleSocketError)
        self.socket_thread.start()

    def updateUI(self):
        # 这里执行UI定期更新操作
        print("UI update tick")

    def handleReceivedData(self, data_dict):
        # 处理子线程传来的数据，更新UI
        print(f"Received data: {data_dict}")
        # 示例：self.statusBar().showMessage(f"Received: {str(data_dict)}")

    def handleSocketError(self, err_msg):
        print(err_msg)

    def closeEvent(self, event):
        # 窗口关闭时停止子线程，清理资源
        self.socket_thread.stop()
        event.accept()

关键修复点 #

• 子线程分离Socket逻辑：把Socket的绑定、监听、接收全部放到QThread中，主线程仅负责UI渲染和信号响应，彻底避免阻塞。
• Socket超时设置：给accept()和recv()设置超时，让子线程能定期检查停止信号，方便安全退出。
• 信号传递数据：子线程无法直接操作UI，通过pyqtSignal将数据和错误信息传递给主线程，由主线程更新UI。
• 修正Socket通信对象：使用conn.recv()进行数据接收，这是accept()返回的客户端专属套接字。
• 资源清理：窗口关闭时主动停止子线程并关闭Socket，避免资源泄漏。

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