PyQt5 应用程序 GUI 响应缓慢，原因不明

Question

I'm creating a PyQt5 application with a socket. In an effort to prevent the socket from blocking GUI updates I outsourced the socket to its own thread. However, I am still getting some issues with the GUI freezing or being slow to update. It usually resumes when the socket receives data and passes it to the GUI, and I'm having a hard time figuring out where. The issue is especially appearing when resizing or moving the main window or its sub window.

I have stripped the below code down to its basics: Create a GUI, start socket thread, Read data from socket, do stuff with it, and display the results in its console buffer. In addition, do stuff with console input (passing the results to the socket has not been implemented yet).

Data is passed between GUI and socket via inQueue and outQueue , and the GUI is supposed to be updated from a QTimer() that triggers an updateGui() function. I've set this to 500 for now, and increasing it to 5 seconds (5000) seems to reduce the glitchiness of the GUI, but not consistently. Ideally I would like to lower this to something like 100ms or even lower for a more responsive GUI, but for now I have it at 500 for debugging purposes.

import os
import sys
import socket
import time

from PyQt5.QtWidgets import QApplication, QMainWindow, QMdiArea
from PyQt5.Qt import QWidget, QMdiSubWindow, QVBoxLayout, QGridLayout, QHBoxLayout, QTextEdit, QLineEdit, QFormLayout, QObject
from PyQt5.QtCore import QTimer
import threading
from threading import Thread
from queue import Queue

class Gui(QMainWindow):
    def __init__(self):

        # Set up GUI with a sub-window named `consoleWindow` from the `ConsoleWindow()` class
        super(Gui, self).__init__()
        self.mainWin = QWidget()
        self.mainWin.resize(640, 480)
        self.winArea = QMdiArea(self.mainWin)
        self.mainLayout = QVBoxLayout()
        self.mainLayout.setStretch(1, 1)
        self.mainLayout.addWidget(self.winArea)
        self.mainWin.setLayout(self.mainLayout)

        # set up consoleWindow
        self.consoleWindow = ConsoleWindow(self)
        self.winArea.addSubWindow(self.consoleWindow)
        self.mainWin.show()

        # Set up message queues for passing data between socketthread and GUI
        self.outQueue = Queue()
        self.inQueue = Queue()

        # Set up and launch socketthread
        self.socket = SocketWorker(self, SETTINGS_HOST, SETTINGS_PORT, self.inQueue, self.outQueue)
        self.socketThread = threading.Thread(target=self.socket.createAndRun, args=(self.inQueue, self.outQueue))
        self.socketThread.start()

        # Periodically do stuff
        self.timer = QTimer(self)
        self.timer.setInterval(500)
        self.timer.timeout.connect(self.updateGui)
        self.timer.start()

    def consoleInput(self, input):
        # TODO do stuff with input. Not a whole lot happening here yet.

    def updateGui(self):
        if self.inQueue.not_empty:
            self.consoleWindow.append(self.inQueue.get())

class ConsoleWindow(QMdiSubWindow):
    def __init__(self, gui):

        # Setup console
        super(ConsoleWindow, self).__init__()
        self.gui = gui
        self.consoleContents = QWidget()
        self.buffer = QTextEdit()
        self.buffer.setReadOnly(True)
        self.input = QLineEdit()
        self.input.returnPressed.connect(self.cmdinput)

        # Create console widgets
        self.consoleLayout = QVBoxLayout(self.consoleContents)
        self.consoleLayout.addWidget(self.buffer)
        self.consoleLayout.addWidget(self.input)

        self.consoleContents.setLayout(self.consoleLayout)
        self.setWidget(self.consoleContents)

    def append(self, string):
        self.buffer.append(string)

    def cmdinput(self):
        self.gui.consoleInput(self.input.text())
        self.input.clear()

class SocketWorker(Thread):
    def __init__(self, gui, host, port, inQueue, outQueue):
        Thread.__init__(self)
        self.gui = gui
        super(SocketWorker, self).__init__()

    def createAndRun(self, inQueue, outQueue):
        self.inQueue = inQueue
        self.outQueue = outQueue

        # SNIP: Create socket, continuously read from it, process incoming data, and shove the results into inQueue. 
        # SNIP: Process any data in outQueue as produced by the GUI, and shove through the socket.

Theories:

• Did I fail at launching SocketWorker in its own thread somehow?
• Is the GUI set up in a severely inefficient matter?
• Something wrong with the queueing?

Update 1:

I've found that the problem disappears if I comment out self.consoleWindow.append(self.inQueue.get()) in def updateGui() , indicating as issue with Queue()

Update 2:

I figured it out. See answer below.

Answer 1

It turns out that queue.Queue() has a timeout, and is therefore causing the lock, as it is being polled very often. The fix is to use get_nowait() instead. However, that caused the method to croak with the exception raise Empty . So I did the lazy fix of wrapping it in a try:except: block, and that did the trick. It now works, and I've reduced the QTimer to 10ms, without any issues. The function now looks like this:

def updateGui(self):
    if self.inQueue.not_empty:
        try:
            self.consoleWindow.append(self.inQueue.get_nowait())
        except:
            True