PyQt4线程绘图时移动窗口引发系统冻结问题求助

Hey there, let's tackle this frustrating freeze problem you're dealing with. The root cause here is almost certainly a conflict between PyQt4's event loop and matplotlib's default event handling—especially when you try to interact with the main widget right as the plot window pops up. Let's break down the fixes step by step:

Core Reasons for the Freeze #

• When you use matplotlib's default plt.show() to pop up a plot, it starts its own independent event loop. This clashes with PyQt4's main event loop, causing both windows and the desktop to freeze when you interact with the main widget mid-plot.
• Even if you're using signals to pass the DataFrame to the main thread, if the plotting logic isn't properly integrated with PyQt's event system, it can block the main thread from handling window movement events.

Step-by-Step Solutions #

1. Force Matplotlib to Use PyQt4's Backend #

First, make sure matplotlib is configured to use PyQt4's backend so it integrates with PyQt's event loop instead of spawning its own. Add this at the top of your script:

import matplotlib
matplotlib.use('Qt4Agg')  # Explicitly set the PyQt4-compatible backend
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

2. Keep All GUI Operations in the Main Thread #

Your worker thread should only handle data processing and progress updates—no GUI-related code allowed. Use PyQt's signals to send the finished DataFrame to the main thread, where you'll handle plotting.

Example Worker Thread Code:

from PyQt4.QtCore import QThread, pyqtSignal
import pandas as pd

class WorkerThread(QThread):
    progress_update = pyqtSignal(int)
    data_ready = pyqtSignal(pd.DataFrame)  # Signal to send the finished DataFrame

    def run(self):
        # Simulate your loop with progress updates
        for progress in range(100):
            # Your actual data processing logic here
            self.progress_update.emit(progress)
            self.msleep(50)  # Simulate work time
        
        # Generate your DataFrame (replace with your actual data)
        df = pd.DataFrame({'x': range(100), 'y': [i**2 for i in range(100)]})
        self.data_ready.emit(df)

3. Embed Matplotlib Plot in a PyQt4 Window #

Instead of using plt.show(), create a PyQt4 dialog/widget to host the matplotlib plot. This way, the plot uses PyQt's event loop, eliminating conflicts.

Example Main Thread Plotting Slot:

from PyQt4.QtGui import QDialog, QVBoxLayout

class MainWidget(QWidget):
    def __init__(self):
        super().__init__()
        # Initialize your main widget, progress bar, etc.
        self.worker = WorkerThread()
        self.worker.progress_update.connect(self.update_progress_bar)
        self.worker.data_ready.connect(self.on_data_ready)
        self.worker.start()

    def update_progress_bar(self, progress):
        self.progress_bar.setValue(progress)  # Update your progress bar here

    def on_data_ready(self, df):
        # Create a PyQt dialog to hold the plot
        plot_dialog = QDialog(self)
        plot_dialog.setWindowTitle("Result Plot")
        layout = QVBoxLayout(plot_dialog)

        # Create matplotlib figure and canvas
        fig = Figure(figsize=(8, 6))
        ax = fig.add_subplot(111)
        df.plot(ax=ax, title="Processed Data")  # Your plotting logic here

        # Add the canvas to the PyQt layout
        canvas = FigureCanvas(fig)
        layout.addWidget(canvas)

        # Show the dialog (uses PyQt's event loop)
        plot_dialog.exec_()  # Or use plot_dialog.show() if you don't want a modal window

4. Avoid Blocking the Main Thread #

If your DataFrame is very large, plotting might take a moment. To prevent the main thread from blocking, wrap the plotting logic in a QTimer.singleShot(0, ...) to ensure it runs after pending events are processed:

from PyQt4.QtCore import QTimer

def on_data_ready(self, df):
    def plot_data():
        # Put the plotting dialog code here
        plot_dialog = QDialog(self)
        # ... rest of the plotting code ...
        plot_dialog.exec_()
    QTimer.singleShot(0, lambda: plot_data())

Additional Checks #

• Ensure you're not calling any GUI methods directly from the worker thread—always use signals to communicate with the main thread.
• Double-check that your PyQt4 and matplotlib versions are compatible with Python 3.6 32-bit (older versions might have bugs with cross-thread signal handling).

内容的提问来源于stack exchange，提问作者Artur Müller Romanov