详细学习PyQt5中的多线程

已于 2023-12-16 23:09:31 修改
阅读量2k 收藏 45
点赞数 29
分类专栏： PyQt5 文章标签： 学习 qt python GUI Pyqt5 开发语言 Python UI
于 2023-12-02 20:26:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49520696/article/details/134757087
版权

Pyqt5相关文章:
快速掌握Pyqt5的三种主窗口
快速掌握Pyqt5的2种弹簧
快速掌握Pyqt5的5种布局
快速弄懂Pyqt5的5种项目视图（Item View）
快速弄懂Pyqt5的4种项目部件（Item Widget）
快速掌握Pyqt5的6种按钮
快速掌握Pyqt5的10种容器（Containers）
快速掌握Pyqt5的20种输入控件（Input Widgets）
快速掌握Pyqt5的9种显示控件
详细学习Pyqt5中的5种布局方式
详细学习Pyqt5中的6种按钮
详细学习Pyqt5中的2种弹簧
详细学习Pyqt5的5种项目视图（Item View）
详细学习Pyqt5的4种项目部件（Item Widget）
详细学习Pyqt5的20种输入控件（Input Widgets）
详细学习Pyqt5的9种显示控件
详细学习Pyqt5的10种容器（Containers）
详细学习PyQt5与数据库交互
详细学习PyQt5中的多线程
快速学习PyQt5的动画和图形效果
快速学习PyQt5的高级自定义控件
快速学会绘制Pyqt5中的所有图（上）
快速学会绘制Pyqt5中的所有图（下）
通过“待办事项列表项目”快速学习Pyqt5的一些特性
待续。。。

在PyQt5应用程序开发中，使用多线程和并发是至关重要的。多线程能够提高应用程序的响应性和性能，使其能够更好地处理复杂的任务和大量数据。本节将探讨为何在PyQt5应用中采用多线程和并发编程是必要的，并引出接下来将要深入讨论的主题：多线程的基本概念、并发编程的需求以及如何与PyQt5框架集成。通过合理的多线程应用，我们可以更好地满足用户期望并提升应用的整体性能。

1. 多线程基础

在Python中，多线程是一种同时执行多个线程的机制，每个线程都是独立的执行流。多线程可以提高程序的并发性，使得多个任务可以并行执行，从而提高整体运行效率。

多线程的优势包括：

  • 提高响应性： 允许在应用程序执行其他任务的同时执行耗时的操作，使应用更加响应用户输入。
  • 提高性能： 能够充分利用多核处理器，加速程序的运行速度。
  • 处理并发任务： 适用于需要同时处理多个任务的场景，如同时下载多个文件或处理多个客户端请求。

基本的多线程示例代码如下：

import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(f"Number: {i}")

def print_letters():
    for letter in 'ABCDE':
        time.sleep(1)
        print(f"Letter: {letter}")

# 创建两个线程
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

# 启动线程
thread1.start()
thread2.start()

# 等待两个线程执行完毕
thread1.join()
thread2.join()

此示例创建了两个线程，一个打印数字，另一个打印字母。通过 start() 启动线程，并通过 join() 等待两个线程执行完毕。

2. PyQt5中的QThread

在PyQt5中，QThread 是用于支持多线程的类。通过使用 QThread，可以在应用程序中实现并发执行的任务。以下是使用 QThread 的基本步骤：

  1. 创建自定义线程类： 继承自 QThread，并重写 run 方法，该方法包含线程的主要逻辑。

  2. 实例化线程对象： 创建自定义线程类的实例。

  3. 连接信号和槽： 使用信号和槽机制将线程的信号连接到主线程中的槽函数，以便在线程完成时更新主界面。

  4. 启动线程： 调用线程对象的 start 方法启动线程的执行。

以下是一个简单的示例代码，演示了如何在PyQt5中使用 QThread：

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

class WorkerThread(QThread):
    finished = pyqtSignal()

    def run(self):
        for i in range(5):
            time.sleep(1)
            print(f"Thread: {i}")

        self.finished.emit()

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label = QLabel("Waiting for thread to finish...", self)
        layout = QVBoxLayout(self)
        layout.addWidget(self.label)

        self.thread = WorkerThread()
        self.thread.finished.connect(self.on_thread_finished)

        # Start the thread when the widget is created
        self.thread.start()

    def on_thread_finished(self):
        self.label.setText("Thread finished!")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，WorkerThread 继承自 QThread，并在 run 方法中定义了线程的执行逻辑。在 MyWidget 中，创建了 WorkerThread 的实例，并连接了 finished 信号到 on_thread_finished 槽函数。在 on_thread_finished 中，更新了主界面的标签文字。

3. 线程间通信

在线程应用中，线程间通信是至关重要的。PyQt5 提供了信号与槽机制，是一种强大的线程间通信方式。以下是线程间通信的基本步骤：

  1. 定义信号： 在线程类中定义一个信号。

  2. 发射信号： 在适当的时机，通过调用 emit 方法发射信号。

  3. 连接信号和槽： 在主线程中连接信号到槽函数，以便在信号发射时执行槽函数。

以下是一个简单的示例代码，演示了如何在两个线程之间进行通信：

from PyQt5.QtCore import QThread, pyqtSignal, QTimer
from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
import sys

class WorkerThread(QThread):
    update_signal = pyqtSignal(str)

    def run(self):
        for i in range(5):
            self.update_signal.emit(f"Thread: {i}")
            self.msleep(1000)

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label = QLabel("Waiting for thread to update...", self)
        layout = QVBoxLayout(self)
        layout.addWidget(self.label)

        self.thread = WorkerThread()
        self.thread.update_signal.connect(self.on_thread_update)

        # Start the thread when the widget is created
        self.thread.start()

    def on_thread_update(self, message):
        self.label.setText(message)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，WorkerThread 类定义了一个名为 update_signal 的信号。在 run 方法中，通过调用 self.update_signal.emit(message) 发射信号，并将消息传递给主线程。在 MyWidget 中，连接了 update_signal 信号到 on_thread_update 槽函数，以更新主界面的标签文字。

4. 数据共享和保护

在多线程应用中，数据共享可能导致竞态条件和不确定性。为了确保数据的安全性，可以使用互斥锁等保护机制。以下是一个简单的例子，演示了如何在多线程中安全地共享数据：

from PyQt5.QtCore import QThread, pyqtSignal, QMutex
from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
import sys

class SharedData:
    def __init__(self):
        self.counter = 0
        self.mutex = QMutex()

    def increment(self):
        self.mutex.lock()
        self.counter += 1
        value = self.counter
        self.mutex.unlock()
        return value

class WorkerThread(QThread):
    update_signal = pyqtSignal(int)

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

    def run(self):
        for i in range(5):
            value = self.shared_data.increment()
            self.update_signal.emit(value)
            self.msleep(1000)

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label = QLabel("Waiting for thread to update...", self)
        layout = QVBoxLayout(self)
        layout.addWidget(self.label)

        self.shared_data = SharedData()
        self.thread = WorkerThread(self.shared_data)
        self.thread.update_signal.connect(self.on_thread_update)

        # Start the thread when the widget is created
        self.thread.start()

    def on_thread_update(self, value):
        self.label.setText(f"Counter Value: {value}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，SharedData 类包含一个计数器和一个互斥锁。increment 方法用于安全地递增计数器的值。在 WorkerThread 中，通过构造函数传递了共享的 SharedData 实例，确保线程安全地访问计数器。

5. 并发编程

并发编程是指同时执行多个独立任务的能力。在PyQt5中，尽管Python存在全局解释器锁（GIL），我们仍然可以通过并发编程实现一些并发性。以下是一个简单的例子，演示了如何使用concurrent.futures模块实现并发编程：

from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
from concurrent.futures import ThreadPoolExecutor
import sys
import time

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label1 = QLabel("Task 1: ", self)
        self.label2 = QLabel("Task 2: ", self)

        layout = QVBoxLayout(self)
        layout.addWidget(self.label1)
        layout.addWidget(self.label2)

        # Create a ThreadPoolExecutor with 2 threads
        self.executor = ThreadPoolExecutor(max_workers=2)

        # Submit tasks to the ThreadPoolExecutor
        task1 = self.executor.submit(self.task_function, 1)
        task2 = self.executor.submit(self.task_function, 2)

        # Use add_done_callback to update the GUI when tasks are completed
        task1.add_done_callback(lambda future: self.label1.setText(f"Task 1: {future.result()}"))
        task2.add_done_callback(lambda future: self.label2.setText(f"Task 2: {future.result()}"))

    def task_function(self, task_number):
        time.sleep(3)  # Simulate a time-consuming task
        return f"Result from Task {task_number}"

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，我们使用concurrent.futures.ThreadPoolExecutor创建了一个包含两个线程的线程池。通过submit方法，我们提交了两个任务，每个任务都是一个耗时的模拟任务。使用add_done_callback，我们能够在任务完成时更新GUI。这样，尽管Python有GIL，我们仍然能够通过线程池实现并发编程。

6. 使用 QThreadPool 进行任务管理

在 PyQt5 中，QThreadPool 是用于管理线程的类。它提供了一种方便的方式来处理并发任务。以下是一个简单的示例，演示如何使用 QThreadPool：

from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
from PyQt5.QtCore import Qt, QRunnable, QThreadPool
import sys
import time

class Worker(QRunnable):
    def __init__(self, task_number):
        super().__init__()
        self.task_number = task_number

    def run(self):
        print(f"Task {self.task_number} is running")
        time.sleep(3)  # Simulate a time-consuming task
        print(f"Task {self.task_number} is complete")

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label1 = QLabel("Task 1: ", self)
        self.label2 = QLabel("Task 2: ", self)

        layout = QVBoxLayout(self)
        layout.addWidget(self.label1)
        layout.addWidget(self.label2)

        # Create a QThreadPool instance
        self.thread_pool = QThreadPool()

        # Submit tasks to the QThreadPool
        task1 = Worker(1)
        task2 = Worker(2)
        self.thread_pool.start(task1)
        self.thread_pool.start(task2)

        # Use signals to update the GUI when tasks are complete
        task1.signals.finished.connect(lambda: self.label1.setText("Task 1 is complete"))
        task2.signals.finished.connect(lambda: self.label2.setText("Task 2 is complete"))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，我们创建了一个名为 Worker 的类，它继承自 QRunnable，并实现了 run 方法。每个任务通过创建 Worker 的实例，并通过 QThreadPool 的 start 方法提交。通过使用信号（QSignal）机制，我们能够在任务完成时更新 GUI。这种方式使得在 PyQt5 应用程序中更容易管理并发任务。

7. 异步编程与协程

在 PyQt5 应用中，异步编程和协程可以提高程序的效率，尤其是在处理涉及网络请求或其他 I/O 操作的任务时。以下是一个简单的示例，演示如何使用异步编程和协程：

import sys
from PyQt5.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget
from PyQt5.QtCore import Qt, QTimer
import asyncio

class MyWidget(QWidget):
    def __init__(self):
        super().__init__()

        self.label = QLabel("Loading...", self)

        layout = QVBoxLayout(self)
        layout.addWidget(self.label)

        # Use QTimer to periodically update the GUI
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.update_label)
        self.timer.start(1000)

        # Run the asyncio event loop in a separate thread
        asyncio.ensure_future(self.run_async_tasks())

    async def run_async_tasks(self):
        # Simulate async tasks (e.g., fetching data from a server)
        for i in range(5):
            await asyncio.sleep(2)  # Simulate an asynchronous task
            print(f"Async Task {i + 1} complete")
            self.update_label_text(f"Async Task {i + 1} complete")

    def update_label_text(self, text):
        # Update the label text safely from another thread
        self.label.setText(text)

    def update_label(self):
        # Trigger the asynchronous tasks periodically
        asyncio.ensure_future(self.run_async_tasks())

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MyWidget()
    widget.show()
    sys.exit(app.exec_())

在这个例子中，我们使用了 asyncio 库来创建异步任务。通过 async def 关键字定义的协程函数可以在异步编程中使用。在 MyWidget 类中，我们使用 QTimer 定时器触发异步任务的运行，同时通过 asyncio.ensure_future 在异步事件循环中运行协程。

这样的设计使得在 PyQt5 应用程序中能够更灵活地处理异步操作，确保不会阻塞主线程。

8. 性能优化和注意事项

在进行多线程开发时，性能优化是至关重要的。以下是一些建议和注意事项，以确保 PyQt5 应用程序的高性能和稳定性：

  1. 避免全局解释器锁（GIL）的影响： Python 全局解释器锁可能会限制多线程并发执行。在 CPU 密集型任务中，考虑使用多进程而非多线程。

  2. 使用线程池管理任务： PyQt5 提供的 QThreadPool 类允许管理线程池，可以有效地管理和执行并发任务，避免过度创建和销毁线程。

  3. 注意线程安全： 在多线程环境中，确保共享数据的访问是线程安全的。使用锁（Mutex）等机制来保护共享资源，防止数据竞争和不一致性。

  4. 定期释放资源： 及时释放不再需要的资源，避免内存泄漏。PyQt5 中的对象在不再需要时应该手动删除或使用 QObject 的 destroyed 信号。

  5. 避免阻塞主线程： 长时间运行的任务应该在后台线程中执行，以避免阻塞主 GUI 线程，保持应用的响应性。

  6. 了解任务的优先级： 通过设置线程和任务的优先级，可以更灵活地控制任务的执行顺序和响应性。

  7. 谨慎使用全局变量： 避免过度使用全局变量，因为它们可能引发数据一致性和线程安全性的问题。

  8. 使用异步编程： 考虑使用异步编程和协程，特别是在处理 I/O 密集型任务时，以提高效率。

  9. 测试和调试： 进行充分的测试和调试，确保多线程代码的正确性和稳定性。使用工具和技术来检测潜在的并发问题。

  10. 文档和注释： 在多线程代码中添加清晰的文档和注释，以便其他开发者能够理解和维护代码。

通过谨慎地遵循这些最佳实践和注意事项，开发者可以确保 PyQt5 应用程序在多线程和并发环境中保持高效和稳定。

9. 实际案例：在 PyQt5 应用中使用多线程的场景

假设我们有一个需要处理大量数据的 PyQt5 图形界面应用，用户可以通过界面触发数据加载、处理、和展示。在这个场景中，使用多线程可以提高用户体验，保持应用的响应性。以下是一个简化的案例：

问题描述：
我们有一个数据处理应用，用户可以通过点击按钮加载大型数据集，进行处理，并在界面上显示结果。由于数据集较大，直接在主线程中进行数据加载和处理可能导致应用假死，用户体验不佳。

解决方案：
通过使用多线程，我们可以将数据加载和处理任务放入后台线程，以确保主线程保持响应性。以下是一个基本的示例：

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

class DataProcessor(QThread):
    data_loaded = pyqtSignal(str)

    def run(self):
        # 模拟数据加载和处理
        data = self.load_data()
        processed_data = self.process_data(data)
        self.data_loaded.emit(processed_data)

    def load_data(self):
        # 模拟数据加载
        self.sleep(3)  # 模拟加载耗时
        return "Large dataset loaded successfully."

    def process_data(self, data):
        # 模拟数据处理
        self.sleep(2)  # 模拟处理耗时
        return f"Processed data: {data.upper()}"

class DataProcessingApp(QWidget):
    def __init__(self):
        super().__init__()

        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        self.result_label = QLabel("Result will be shown here.")
        layout.addWidget(self.result_label)

        load_button = QPushButton("Load and Process Data")
        load_button.clicked.connect(self.load_and_process_data)
        layout.addWidget(load_button)

        self.setLayout(layout)
        self.setGeometry(300, 300, 400, 200)
        self.setWindowTitle("Data Processing App")
        self.show()

    def load_and_process_data(self):
        # 创建并启动数据处理线程
        data_processor = DataProcessor()
        data_processor.data_loaded.connect(self.update_result_label)
        data_processor.start()

    def update_result_label(self, result):
        # 在主线程中更新界面
        self.result_label.setText(result)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = DataProcessingApp()
    sys.exit(app.exec_())

在这个案例中，点击按钮会触发 DataProcessor 线程执行数据加载和处理任务，加载完成后，通过信号将结果传递给主线程，主线程更新界面上的标签显示结果。这确保了应用在数据处理过程中仍能保持响应性。

10. 结论

通过本文的探讨，我们深入了解了在 PyQt5 中使用多线程和并发的关键概念、技术和最佳实践。多线程和并发在图形用户界面应用程序中的应用是至关重要的，可以提高应用的性能、响应性和用户体验。

关键点总结如下：

  1. 多线程基础： 理解 Python 中的多线程概念，以及多线程的优势和适用场景。

  2. QThread 类的使用： 学会在 PyQt5 中使用 QThread 类来创建和管理多线程，确保线程之间的协同工作。

  3. 线程间通信： 理解在多线程应用中如何进行线程间的通信，特别是通过 PyQt5 的信号与槽机制的应用。

  4. 数据共享和保护： 学习在多线程应用中处理数据共享问题的方法，包括互斥锁和其他保护机制。

  5. 并发编程： 了解并发编程的概念，以及 Python GIL 对并发的影响，同时掌握并发编程的实例和优化技巧。

  6. QThreadPool 的使用： 学会使用 QThreadPool 类进行任务管理，提高多线程应用的效率。

  7. 异步编程与协程： 引入异步编程的概念，了解 Python 中协程的基本用法，以及它们在 PyQt5 中的实际应用场景。

  8. 性能优化和注意事项： 提供关于多线程性能优化的最佳实践，同时讨论在 PyQt5 应用程序中使用多线程时的注意事项。

  9. 实际案例： 通过一个实际应用案例，展示在 PyQt5 应用程序中如何有效地使用多线程解决问题，分析线程设计和优化策略。

  10. 结论： 强调在合适的场景下，深入理解多线程和并发的知识对于创建高性能、响应性和用户友好的 PyQt5 应用程序至关重要。

通过运用这些技术和最佳实践，开发者可以更好地利用 PyQt5 框架，创造出更加强大、高效且用户友好的图形用户界面应用。

CClaris
关注
  • 29
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyQt5多线程防卡死和多窗口用法的实现
09-16
主要介绍了PyQt5多线程防卡死和多窗口用法的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
PyQt5中多线程模块QThread和线程池ThreadPoolExecutor解决PyQt5界面程序执行比较耗时操作无响应问题
07-09
1.资源简介：PyQt5中使用多线程模块QThread解决了PyQt5界面程序执行比较耗时操作时，程序卡顿出现的无响应以及界面输出无法实时显示的问题，采用线程池ThreadPoolExecutor解决了ping多个IP多任务耗时问题。 2.适用人群：想学习PyQt5中多线程模块QThread和线程池ThreadPoolExecutor知识的人。
PyQt5多线程使用
只想整天学习
01-17 456
本案例使用PyQt5多线程实现一个UI界面同时显示3个时间实时更新控件，从而直观地了解到Qt多线程是如何进行工作的。
PyQt5中多线程模块QThread使用方法的实现
09-18
主要介绍了PyQt5中多线程模块QThread使用方法的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
如何使用PyQt进行多线程编程？
2301_78316786的博客
08-25 155
在这个例子中，我们创建了一个新的线程 t，并且在这个线程中运行了一个叫做 worker 的函数。这是因为 QLabel 的文本是在主线程中创建的，所以如果你试图在一个不同的线程中修改它，你的程序可能会崩溃。这样，即使我们的 worker 函数在一个不同的线程中运行，我们的程序也不会崩溃了。这个模块让我们可以创建和管理多个线程，这些线程可以同时运行，让我们的程序可以同时处理多个任务。下面是一个简单的例子，我们在这个例子中创建了一个新的线程，这个线程会不断地更新一个 QLabel 的文本。
九、PyQt5多线程编程
ungoing的博客
10-13 8070
我们先对线程的分类及概述做简单介绍，然后详细讲解Python中进行线程编程的主要两个类——QTimer计时器类、QThread线程类，并对线程的具体实现进行详细讲解。
PyQT——多线程(QThread)
极地星辰
04-26 1万+
PyQT5线程：多线程QThread前言一、应用场景二、使用多线程解决卡顿和假死第一种：线程锁(QMutex)第二种：信号(Signal) 前言 一、应用场景 在编写GUI界面中，通常用会有一些按钮，点击后触发事件，比如去下载一个文件或者做一些操作，这些操作会耗时，如果不能及时结束，主线程将会阻塞，这样界面就会出现未响应的状态，因此必须使用多线程来解决这个问题。 二、使用多线程 解决卡顿和假死 1.两个按钮，分别在控制台打印不同的内容，分别点击两个按钮后，控制台会依次打印内容，多次点击按钮，程序会先循环完上
PyQt5自学记录（1）——PyQt5多线程实现详解
热门推荐
qq_40784418的博客
04-10 1万+
PyQt5实现多线程
pyqt5学习笔记(三)——多线程的使用
Luke8844的博客
05-19 2761
1、问题的出现 当按钮控件按下后，如果操作比较耗时，就会出现界面假死、卡死的现象，如果要想在这个过程中将运行过程中的内容打印在文本控件上，此时也不会出现内容。 现在模拟一下，在按钮的槽函数里面添加一个休眠函数，添加一个for循环，循环一次休眠1秒，模拟耗时函数，每次循环之后将信息打印在文本控件中，同时信息也在后台打印一下。 本次演示需要两个控件，一个pushButton，一个textEdit（记得将ui文件转化为py文件） 添加信号和槽函数 # 信号 self.pushButton
PyQt5——多线程
绝尘
09-26 2693
多线程 多线程技术设计三种方法，其中一种是使用计数器模块QTimer，一种是使用多线程模块QThread，还有一种使用事件处理的功能。 QTimer 如果要在应用程序汇总周期性地进行某项操作，比如周期性地检测主机的CPU，则需要用到QTimer（定时器）。QTimer类提供了重复和单次的定时器。要使用定时器，则需要先创建一个QTImer实例，将其timeout信号连接到相应的槽，并调用start。...
PyQt5中异步刷新UI+Python中的多线程+python中使用subprocess总结
12-18
PyQt5中异步刷新UI和Python中的多线程总结 学习python和PyQt5的过程中，做了demo，可以从电脑端向手push文件和安装apk的GUIdemo，初学者可从这个例子中学到很多知识。涉及到PyQt5中异步刷新UI+Python中的多线程+...
操作系统--线程
KobeSacre的博客
10-25 183
线程 什么是是线程? 进程中的一条执行流程 线程的优点 一个进程可以同时存在多个线程 各个线程之间并发执行 各个线程之间共享地址空间和文件等资源 线程的缺点 一个线程崩溃将导致其余所有线程崩溃 线程所需的资源 进程与线程的比较 线程的实现 用户线程: 在用户空间实现(操作系统看不到) 用户线程的缺点 内核线程: 在内核空间实现(归操作系统管理) 轻量级线程: 在内核空间实现, 支持用户线程 用户线程与内核线程的对应关系 多对一 一对一 多对多 ...
基于PyQt5中QThread类的多线程应用实例
weixin_45067242的博客
04-27 1443
与参考文章不同的是，此处新建一个main.py将UI与逻辑代码分离开发，写一个主程序入口用于加载画面，并给后续的触发事件程序提供入口，同时将创建兔子乌龟线程对象、将线程信号连接到槽函数及开始两个线程都集中写到一个方法中。然后在创建定义的两个线程类对象，通过start()方法启动。，在Qt Designer中创建一个主要包含两个TextEdit控件和一个PushButton控件的窗口，计完成后保存为.ui文件，并使用PyUIC工具将其转换为.py文件。
PYQT5学习文档3-多线程应用，防止主界面假死
Allen_TTT的博客
02-27 419
pyqt5多线程的应用
Pyqt5实现多线程程序
tangbiubiu的博客
11-23 527
使用pyqt5制作多线程程序
PYQT5实现多线程的方法
GDUT_ZXM的博客
11-17 8277
pyqt5处理多线程主要有三种方法： a.使用计时器模块QTimer b.使用多线程模块QThread c.使用事件处理功能 QTimer相当于一个定时器，每当定时器时间溢出后，会执行相关的函数。这个时候程序会从主线程界面跳到QTimer函数中，如果QTimer函数中有延时或者处理时间较长，就会出现界面失去响应，造成界面卡顿的现象。 QThread等于新开一个线程专门处理耗时间的程序，UI主线程显示界面，当子线程处理好数据后通过自定义的信号与槽，将数据交给主线程刷新界面。由于UI主线程一直运行，子线程的延时
PyQt中的多线程QThread示例
hubing_hust的专栏
12-08 1万+
PyQt中的多线程QThread示例。传统的图形用户界面应用程序都只有一个执行线程，并且一次只执行一个操作。如果用户从用户界面中调用一个比较耗时的操作，那么当执行这个程序时，虽然实际上该操作正在进行，但用户界面通常会冻结而不再响应。为了解决这个问题，通常会让用户的UI界面运行在它自己的线程中，而另外的事件处理过程则发生在一个或多个其他线程中。这样做之后，即使在处理那些数据密集的事件时，应用程序也能对GUI用户界面保持响应。
Vitis HLS 学习笔记--优化指令-ARRAY_PARTITION
最新发布
hi94的博客
04-22 1295
ARRAY_PARTITION 指令中非常重要，它用于优化数组的存储和访问。该指令可以将一个大数组分割成多个小数组，以提高并行处理能力和减少访问延迟。
pyqt 多线程
05-26
PyQt 是一个基于 Python 的 GUI 编程框架，支持多线程编程。在 PyQt 中，可以通过 QThread 类来创建新的线程，还可以使用信号和槽机制来进行不同线程之间的通信。 下面是一个简单的 PyQt 多线程示例： ```python import sys from PyQt5.QtCore import QThread, pyqtSignal from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel class Worker(QThread): finished = pyqtSignal() progress = pyqtSignal(int) def __init__(self, parent=None): super().__init__(parent) def run(self): for i in range(1, 101): self.progress.emit(i) self.msleep(100) self.finished.emit() class MainWindow(QMainWindow): def __init__(self, parent=None): super().__init__(parent) self.label = QLabel("Progress Bar", self) self.label.setGeometry(50, 50, 200, 50) self.thread = Worker(self) self.thread.finished.connect(self.finished) self.thread.progress.connect(self.update_progress) self.thread.start() def update_progress(self, value): self.label.setText(f"Progress: {value}%") def finished(self): self.label.setText("Finished") if __name__ == "__main__": app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_()) ``` 在这个示例中，我们创建了一个名为 Worker 的 QThread 类，该类模拟了一个长时间运行的任务。在 MainWindow 类中，我们创建了一个 Worker 实例，并启动它的运行。在 Worker 类中，我们使用 pyqtSignal 定义了两个信号：finished 和 progress。finished 信号在 Worker 运行结束时发出，progress 信号则在 Worker 运行期间定期发出，以更新进度条。 在 MainWindow 类中，我们将 progress 信号连接到 update_progress() 方法，该方法更新标签文本以显示当前进度。我们还将 finished 信号连接到 finished() 方法，该方法在 Worker 运行结束时更新标签文本。最后，我们调用 thread.start() 方法启动 Worker 线程。 这只是一个简单的 PyQt 多线程示例，还有许多其他的用法和技巧可以学习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值