pyside6 不使用signal 实现 多线程

可以使用 QThread 类来实现多线程，具体实现方式可以参考以下代码：

from PySide6.QtCore import QThread

class Worker(QThread):
    def __init__(self, parent=None):
        super().__init__(parent)

    def run(self):
        # 在这里编写需要在子线程中执行的代码
        pass

在主线程中创建 Worker 对象，并调用 start() 方法启动子线程：

worker = Worker()
worker.start()

需要注意的是，在子线程中不能直接访问 GUI 控件，如果需要更新 GUI，可以使用信号与槽机制。

相关问题

pyside6实现多线程通讯

在 PySide6 中，可以使用 QThread 和信号槽机制来实现多线程通信。下面是一个简单的例子：

from PySide6.QtCore import QObject, QThread, Signal


class Worker(QObject):
    finished = Signal()
    progress = Signal(int)

    def run(self):
        for i in range(1, 11):
            self.progress.emit(i * 10)
            QThread.sleep(1)
        self.finished.emit()


class Main(QObject):
    def __init__(self):
        super().__init__()

        self.worker = Worker()
        self.thread = QThread()
        self.worker.moveToThread(self.thread)

        self.worker.finished.connect(self.on_finished)
        self.worker.progress.connect(self.on_progress)

        self.thread.started.connect(self.worker.run)

    def start(self):
        self.thread.start()

    def on_progress(self, value):
        print(f"Progress: {value}%")

    def on_finished(self):
        print("Finished")


if __name__ == "__main__":
    main = Main()
    main.start()

在这个例子中，我们创建了两个 QObject 类，一个是 Worker，一个是 Main。Worker 类用于执行耗时的任务，Main 类用于启动和管理 Worker 类的线程。Worker 类中定义了两个信号，一个是进度信号 progress，一个是完成信号 finished。在 run 方法中，我们使用 sleep 方法模拟了一个耗时的任务，并在循环中发射了 progress 信号。

在 Main 类中，我们创建了一个 Worker 实例和一个 QThread 实例，并将 Worker 实例移动到了 QThread 中。我们通过连接信号和槽的方式监听 Worker 实例发射的信号，当 progress 信号被发射时，会调用 on_progress 方法打印进度信息，当 finished 信号被发射时，会调用 on_finished 方法打印完成信息。

最后，我们在 if __name__ == "__main__" 中创建了 Main 实例，并调用 start 方法启动线程。这样就可以在多线程环境下执行任务并实现通信了。

pyside2如何实现多线程

PySide2可以使用Python内置的`threading`模块来实现多线程。下面是一个基本示例：

from PySide2.QtCore import QThread, Signal

class MyThread(QThread):
    finished = Signal()  # 用于发射线程完成的信号

    def __init__(self):
        super().__init__()

    def run(self):
        # 这里是线程执行的代码
        for i in range(10):
            print(i)
        self.finished.emit()  # 发射线程完成的信号

在上面的代码中，我们创建了一个继承自`QThread`的子类`MyThread`。这个子类中定义了一个`finished`信号，用于发射线程完成的信号。在`run`方法中编写线程执行的代码，例如循环打印数字。当线程执行完成后，我们发射`finished`信号。

接下来，我们可以在主线程中创建一个`MyThread`对象，并启动它：

my_thread = MyThread()
my_thread.start()

这样就可以启动一个新的线程来执行`MyThread`中定义的任务了。同时，我们也可以在主线程中监听`MyThread`对象的`finished`信号，并在信号被发射时执行相应的处理：

my_thread = MyThread()
my_thread.finished.connect(handle_thread_finished)
my_thread.start()

def handle_thread_finished():
    print("Thread finished.")

在上面的代码中，我们将`MyThread`对象的`finished`信号连接到了一个名为`handle_thread_finished`的处理函数。当线程执行完成后，`handle_thread_finished`函数将被调用，打印一条消息。