用ChatGPT辅助编程靠谱吗？

我在用PySide6写程序的时候，用到了QThreadPool，想知道如何获取等待任务数。我想让ChatGPT来帮我回答一下这个问题。看看它的回答：

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task):
        super().__init__()
        self.task = task
        self.signals = SignalSource()

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建计数变量，用于估计等待任务的数量
    waiting_tasks_count = 0

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task)
        worker.signals.taskDone.connect(signalSource.handleTaskDone)

        # 提交任务到线程池
        threadPool.start(worker)

        # 增加等待任务的计数
        waiting_tasks_count += 1

    # 减少完成任务的计数
    waiting_tasks_count -= len(tasks)

    # 输出当前等待任务的数量
    print("当前等待任务的数量:", waiting_tasks_count)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

我们来看一下ChatGPT给的这段代码

它在创建线程池的时候就创建了一个信号源SignalSource实例

# 创建信号源实例
signalSource = SignalSource()

又在Worker的初始化方法里又创建了SignalSource实例

self.signals = SignalSource()

它在创建Worker的时候，连接的是最开始的那个信号源

worker.signals.taskDone.connect(signalSource.handleTaskDone)

在Worker中完成任务后发送信号

# 发送任务完成的信号
self.signals.taskDone.emit(result)

注意这里，它发送信号不是发送给连接的信号源，而是发送给了Worker类本身创建的信号源。这还真是迷之操作，好吧，提醒一下ChatGPT，让它改一下。

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)
        worker.signals = signalSource

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

这回改的更离谱

worker = Worker(task, signalSource)
worker.signals = signalSource

信号源实例已经通过参数传进去了，却又来了个赋值操作。而且更重要的是没有连接信号源，告诉ChatGPT继续改。

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)
        worker.signals.taskDone.connect(signalSource.handleTaskDone)

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

我们来看下运行结果，每个任务都被执行了三次

继续让ChatGPT改

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)
        worker.signals.taskDone.connect(signalSource.handleTaskDone, Qt.AutoConnection)

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

执行结果依然是任务被执行了三次

再让ChatGPT改

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot, Qt
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)

        # 断开之前的连接，以避免多次连接
        worker.signals.taskDone.disconnect()

        worker.signals.taskDone.connect(signalSource.handleTaskDone, Qt.AutoConnection)

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

执行后报错

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

    def __init__(self):
        super().__init__()
        self.connected = False

    def connectTaskDone(self, slot):
        if not self.connected:
            self.taskDone.connect(slot)
            self.connected = True

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)

        # 使用新的方法连接信号槽
        signalSource.connectTaskDone(signalSource.handleTaskDone)

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

连接信号槽需要放在for循环吗？显示不对

# 使用新的方法连接信号槽
signalSource.connectTaskDone(signalSource.handleTaskDone)

from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QThreadPool, QRunnable, QObject, Signal, Slot
import time

# 自定义信号源类
class SignalSource(QObject):
    taskDone = Signal(int)

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

    @Slot(int)
    def handleTaskDone(self, result):
        print("Task result:", result)

# 自定义工作类
class Worker(QRunnable):
    def __init__(self, task, signals):
        super().__init__()
        self.task = task
        self.signals = signals

    def run(self):
        # 模拟一些耗时的任务
        time.sleep(2)
        result = self.task * 2

        # 发送任务完成的信号
        self.signals.taskDone.emit(result)

if __name__ == "__main__":
    app = QApplication([])

    # 创建线程池
    threadPool = QThreadPool()

    # 创建信号源实例
    signalSource = SignalSource()

    # 使用新的方法连接信号槽
    signalSource.taskDone.connect(signalSource.handleTaskDone)

    # 创建多个工作对象并连接信号
    tasks = [10, 20, 30]
    for task in tasks:
        worker = Worker(task, signalSource)

        # 提交任务到线程池
        threadPool.start(worker)

    # 等待线程池中的所有任务完成
    threadPool.waitForDone()

    app.exec()

这次终于对了！真是历尽了无数坎坷才完成这么个小demo，大家说用ChatGPT编程靠谱吗？