能否在非主线程调用matplotlib的axes.lines.remove()及修改绘图元素？

Great question—this is a super common pitfall when mixing Matplotlib with PyQt and multi-threading. Let's break this down clearly:

First and foremost: Matplotlib's GUI backends (including Qt4Agg) are not thread-safe. All operations involving creating, deleting, or modifying plot elements (lines, annotations, arrows, axis data, etc.), as well as any actions that trigger layout redraws, must be executed in the main thread (the Qt event loop thread).

The RuntimeError('main thread is not in main loop',) and Tcl_AsyncDelete exceptions you're seeing are direct results of worker threads manipulating GUI/plot objects owned by the main thread—this breaks the thread isolation required by both Qt and Matplotlib.

• RuntimeError: Matplotlib's event loop is bound to the main thread. When a worker thread tries to access or modify resources dependent on this main loop, it throws this error.
• Tcl_AsyncDelete: PyQt4 relies on Tcl/Tk for some underlying event handling. If a worker thread deletes an async handler created by the main thread, this memory safety exception is triggered, leading to a core dump.

Worker threads should only handle data calculation/processing. All plot-related operations must be passed to the main thread using Qt's signal-slot mechanism—this is Qt's official thread-safe way to communicate across threads, as cross-thread signals are automatically posted to the target thread's event loop.

Code Refactoring Example #

1. Main Thread Window Class: Define Signals & Safe Slot Functions

import matplotlib
matplotlib.use('Qt4Agg')  # Must initialize backend in main thread
import matplotlib.pyplot as plt
from PyQt4.QtCore import QMainWindow, pyqtSignal, QThread

class PlotWindow(QMainWindow):
    # Define signals for safe cross-thread operations
    remove_line_signal = pyqtSignal(object)
    update_axis_signal = pyqtSignal(list, list)

    def __init__(self):
        super().__init__()
        # Initialize Matplotlib objects (main thread only)
        self.fig = plt.figure()
        self.axes_plot = self.fig.add_subplot(111)
        self.plot_lines = []

        # Connect signals to thread-safe slot functions
        self.remove_line_signal.connect(self._remove_line_safe)
        self.update_axis_signal.connect(self._update_axis_safe)

    def add_line(self, x_data, y_data):
        # Safe line addition (main thread only)
        line, = self.axes_plot.plot(x_data, y_data)
        self.plot_lines.append(line)
        self.fig.canvas.draw_idle()

    def _remove_line_safe(self, line):
        # Slot function runs in main thread: safely remove line
        if line in self.axes_plot.lines:
            self.axes_plot.lines.remove(line)
            self.plot_lines.remove(line)
            self.fig.canvas.draw_idle()  # Async redraw to avoid blocking

    def _update_axis_safe(self, new_x, new_y):
        # Slot function runs in main thread: safely update axis limits
        self.axes_plot.set_xlim(min(new_x), max(new_x))
        self.axes_plot.set_ylim(min(new_y), max(new_y))
        self.fig.canvas.draw_idle()

2. Worker Thread Class: Only Handle Data & Emit Signals

class PlotWorker(QThread):
    def __init__(self, main_window):
        super().__init__()
        self.main_window = main_window
        self.running = True

    def run(self):
        # Simulate complex, loop-based data processing
        while self.running:
            # Example 1: Remove excess lines (only identify target, emit signal)
            if len(self.main_window.plot_lines) > 5:
                line_to_remove = self.main_window.plot_lines[0]
                self.main_window.remove_line_signal.emit(line_to_remove)

            # Example 2: Calculate new data, emit signal to update axis
            new_x = [i for i in range(0, 100)]
            new_y = [i**2 for i in new_x]
            self.main_window.update_axis_signal.emit(new_x, new_y)

            self.msleep(500)  # Simulate computation time

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

• Strict Thread Isolation: Worker threads should never directly access or modify any Matplotlib GUI objects (Figure, Axes, Line2D, etc.), nor call GUI-related methods like plt.show() or fig.canvas.draw().
• Main Thread Initialization: All Matplotlib backend setup (matplotlib.use()) and plot object creation (plt.figure(), add_subplot()) must happen in the main thread.
• Async Redraws: Use fig.canvas.draw_idle() instead of draw()—it redraws when the Qt event loop is idle, preventing main thread blocking.
• Batch Operations: If you need frequent plot updates, batch requests (e.g., collect multiple lines to delete before emitting a signal) to reduce signal frequency and avoid overwhelming the event loop.
• Avoid Direct Cross-Thread Calls: Never call main thread methods directly from a worker. If you must invoke a method, use QMetaObject.invokeMethod with Qt.QueuedConnection to ensure it runs in the main thread.

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