PyQt学习系列04-多线程与异步编程

江畔柳前堤

已于 2025-05-24 13:57:43 修改

阅读量668

点赞数 28

分类专栏：软件开发 pyQT 文章标签： pyqt 学习 javascript 开发语言 ecmascript python 人工智能

于 2025-05-23 13:04:21 首次发布

本文链接：https://blog.csdn.net/qq_51605551/article/details/148164626

版权

软件开发同时被 2 个专栏收录

20 篇文章

订阅专栏

pyQT

11 篇文章

订阅专栏

PyQt学习系列笔记（Python Qt框架）

第四课：PyQt的多线程与异步编程

一、多线程与异步编程概述

1.1 为什么需要多线程？

在GUI应用程序中，长时间运行的任务（如文件读写、网络请求、复杂计算）会阻塞主线程，导致界面卡顿甚至冻结。通过多线程和异步编程，可以将这些任务移至后台线程，确保主线程（UI线程）的响应性。

核心目标：

避免界面卡顿：将耗时操作与UI更新分离。
提高并发性能：同时处理多个任务（如多文件下载）。
实现异步通信：支持非阻塞式网络请求或数据库操作。

二、PyQt的线程模型

2.1 QThread vs Python threading

PyQt提供了QThread类，专为与Qt事件循环集成而设计，推荐用于以下场景：

需要与UI组件交互（如更新进度条）。
需要利用Qt的信号-槽机制进行线程间通信。

对比threading模块：

特性	`QThread`	`threading`
事件循环支持	✅ 与Qt事件循环集成	❌ 需手动管理
信号-槽通信	✅ 原生支持	❌ 需手动实现
线程生命周期管理	✅ 自动管理	❌ 需手动管理
与UI组件兼容性	✅ 安全	❌ 高风险

三、QThread基础用法

3.1 创建工作线程

通过继承QThread并重写run()方法定义线程逻辑。

示例：模拟耗时任务

from PyQt5.QtCore import QThread, pyqtSignal
from PyQt5.QtWidgets import QApplication, QPushButton, QLabel, QVBoxLayout, QWidget
import time

class WorkerThread(QThread):
    progress = pyqtSignal(int)  # 定义进度信号

    def run(self):
        for i in range(101):
            time.sleep(0.05)  # 模拟耗时操作
            self.progress.emit(i)  # 发送进度信号
        self.progress.emit(100)

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QThread 示例")
        self.layout = QVBoxLayout()

        self.button = QPushButton("开始任务")
        self.label = QLabel("进度: 0%")

        self.button.clicked.connect(self.start_task)
        self.layout.addWidget(self.button)
        self.layout.addWidget(self.label)
        self.setLayout(self.layout)

    def start_task(self):
        self.thread = WorkerThread()
        self.thread.progress.connect(self.update_label)
        self.thread.start()

    def update_label(self, value):
        self.label.setText(f"进度: {value}%")

if __name__ == "__main__":
    app = QApplication([])
    window = MainWindow()
    window.show()
    app.exec_()

3.2 线程间通信

通过信号-槽机制实现线程间数据传递。
关键原则：

信号只能由主线程发出（如UI更新）。
子线程不能直接操作UI组件。

示例：子线程发送数据到主线程

class WorkerThread(QThread):
    data_ready = pyqtSignal(str)  # 定义数据信号

    def run(self):
        result = "计算结果"
        self.data_ready.emit(result)  # 发送数据到主线程

四、QRunnable与QThreadPool

4.1 轻量级任务处理

QRunnable是线程池中可执行的任务单元，适合处理大量短生命周期任务。

核心优势：

资源隔离：任务由线程池管理，避免频繁创建/销毁线程。
高并发：适用于批量任务（如文件批量处理、网络请求）。

示例：使用QRunnable实现批量文件读取

from PyQt5.QtCore import QRunnable, QThreadPool, pyqtSignal

class FileLoader(QRunnable):
    finished = pyqtSignal(str)  # 定义完成信号

    def __init__(self, filename):
        super().__init__()
        self.filename = filename

    def run(self):
        with open(self.filename, 'r') as f:
            data = f.read()
        self.finished.emit(data)  # 发送数据到主线程

# 主线程中启动任务
pool = QThreadPool()
loader1 = FileLoader("file1.txt")
loader1.finished.connect(lambda data: print("文件1内容:", data))
loader2 = FileLoader("file2.txt")
loader2.finished.connect(lambda data: print("文件2内容:", data))
pool.start(loader1)
pool.start(loader2)

4.2 线程池配置

通过QThreadPool管理线程池的生命周期和资源。

常用方法：

setExpiryTimeout(timeout)：设置线程空闲超时时间。
setMaxThreadCount(count)：限制最大线程数。
activeThreadCount()：获取当前活跃线程数。

示例：配置线程池

pool = QThreadPool()
pool.setMaxThreadCount(5)  # 限制最大线程数
pool.setExpiryTimeout(60000)  # 设置线程空闲超时时间为60秒

五、异步编程进阶

5.1 concurrent.futures 简化线程池

通过ThreadPoolExecutor结合信号-槽实现更简洁的异步任务管理。

示例：使用ThreadPoolExecutor执行异步任务

from concurrent.futures import ThreadPoolExecutor
from PyQt5.QtCore import pyqtSignal, QObject

class AsyncWorker(QObject):
    result_ready = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.executor = ThreadPoolExecutor(max_workers=3)

    def submit_task(self, func, *args):
        future = self.executor.submit(func, *args)
        future.add_done_callback(lambda f: self.result_ready.emit(f.result()))

# 使用示例
def long_running_task(name):
    time.sleep(2)
    return f"任务 {name} 完成"

worker = AsyncWorker()
worker.result_ready.connect(lambda msg: print(msg))
worker.submit_task(long_running_task, "A")
worker.submit_task(long_running_task, "B")

5.2 asyncio 与 Qt 的集成

PySide6 引入 QtAsyncio，支持协程与 Qt 事件循环的无缝结合。

示例：使用 asyncio 实现异步定时器

from PySide6.QtAsync import QtAsync
import asyncio

async def async_timer():
    for i in range(5):
        print(f"计时器: {i}")
        await asyncio.sleep(1)

# 启动事件循环
QtAsync.run(async_timer())

六、多线程与异步的高级技巧

6.1 中止线程的正确方式

直接调用 QThread.terminate() 是不安全的，推荐通过标志位控制任务结束。

示例：安全中止线程

class CancellableThread(QThread):
    stop_signal = pyqtSignal()

    def __init__(self):
        super().__init__()
        self._running = True

    def run(self):
        while self._running:
            # 执行任务
            time.sleep(0.1)

    def stop(self):
        self._running = False
        self.stop_signal.emit()

6.2 线程安全与数据共享

共享数据：使用 QMutex 或 QReadWriteLock 保护共享资源。
只读数据：通过 QSharedMemory 或 QAtomicPointer 实现线程间只读访问。

示例：使用 QMutex 保护共享数据

from PyQt5.QtCore import QMutex, QThread

mutex = QMutex()
shared_data = 0

class Worker(QThread):
    def run(self):
        global shared_data
        for _ in range(100000):
            mutex.lock()
            shared_data += 1
            mutex.unlock()

七、多进程与分布式计算

7.1 multiprocessing 模块

对于 CPU 密集型任务，推荐使用 multiprocessing 模块实现多进程。

示例：多进程计算

from multiprocessing import Process, Queue

def compute(queue):
    result = sum(range(1000000))
    queue.put(result)

queue = Queue()
process = Process(target=compute, args=(queue,))
process.start()
print("计算结果:", queue.get())
process.join()

7.2 分布式任务队列

使用 Celery 或 Dask 实现跨机器的分布式任务调度。

示例：使用 Celery 分布式任务

from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def add(x, y):
    return x + y

result = add.delay(4, 4)
print(result.get())