多线程求教~~

清風

FishC 发表于 2024-3-14 22:20
如果在窗体B中的按钮调用了窗体A中的方法来处理耗时任务，那么将线程类定义在窗体A中是可行的。您可以 ...

"如果在窗体B中的按钮调用了窗体A中的方法来处理耗时任务，那么将线程类定义在窗体A中是可行的。" 实际上，我并没有如你所讲的B窗体来调用A窗体的方法，因为打开B窗体时，A窗体已经关闭了。。。
并且 ，所有按钮都是在B窗体中。。。按钮方法也是全部置于B窗体中。。。

下面这个fro语句卡顿的很厉害，麻烦想想办法。

for sheet_name in Exclud_Book.sheet_names():

回复请注意Python格式

yxxxzx123

FishC 发表于 2024-3-14 22:20
如果在窗体B中的按钮调用了窗体A中的方法来处理耗时任务，那么将线程类定义在窗体A中是可行的。您可以 ...

"如果在窗体B中的按钮调用了窗体A中的方法来处理耗时任务，那么将线程类定义在窗体A中是可行的。" 实际上，我并没有如你所讲的B窗体来调用A窗体的方法，因为打开B窗体时，A窗体已经关闭了。。。
并且 ，所有按钮都是在B窗体中。。。按钮方法也是全部置于B窗体中。。。

下面这个fro语句卡顿的很厉害，麻烦想想办法。

for sheet_name in Exclud_Book.sheet_names():

回复请注意Python格式

清風

我忘记了AI是不理我的。。。。

FishC

yxxxzx123 发表于 2024-03-15 09:17
"如果在窗体B中的按钮调用了窗体A中的方法来处理耗时 ...

如果你的窗口A已经关闭，并且所有的按钮和相关方法都在窗口B中，那么你可以将线程类定义在窗口B中，以便在按钮方法中启动线程来处理耗时任务。下面是一个可能的解决方案，使用`QRunnable`和`QThreadPool`来实现多线程执行任务的方式。

1. from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QPushButton, QLabel
   
2. from PySide6.QtCore import QRunnable, QObject, Signal, Qt, QThreadPool
   
3. 
   
4. class MyRunnable(QRunnable):
   
5.     def __init__(self):
   
6.         super().__init__()
   
7.         self.setAutoDelete(True)
   
8. 
   
9.     def run(self):
   
10.         # 在这里编写耗时的任务代码
    
11.         # ...
    
12.         # 任务完成后发射信号
    
13.         exclude_rules = {'1': exclude_rows, '2': exclude_cols}
    
14.         self.finished.emit(exclude_rules)
    
15. 
    
16.     finished = Signal(dict)
    
17. 
    
18. class WindowB(QMainWindow):
    
19.     def __init__(self):
    
20.         super().__init__()
    
21.         self.threadpool = QThreadPool()
    
22.         
    
23.         self.label = QLabel("进度条")
    
24.         self.button = QPushButton("启动线程")
    
25.         self.button.clicked.connect(self.start_thread)
    
26. 
    
27.         layout = QVBoxLayout()
    
28.         layout.addWidget(self.label)
    
29.         layout.addWidget(self.button)
    
30. 
    
31.         central_widget = QWidget()
    
32.         central_widget.setLayout(layout)
    
33.         self.setCentralWidget(central_widget)
    
34. 
    
35.     def start_thread(self):
    
36.         # 创建并配置任务对象
    
37.         runnable = MyRunnable()
    
38.         runnable.finished.connect(self.on_operation_finished)
    
39.         
    
40.         # 将任务提交给线程池
    
41.         self.threadpool.start(runnable)
    
42. 
    
43.     def on_operation_finished(self, exclude_rules):
    
44.         # 在这里处理线程信号
    
45.         print("操作完成:", exclude_rules)
    
46.         # ...
    
47. 
    
48. app = QApplication([])
    
49. window_b = WindowB()
    
50. window_b.show()
    
51. app.exec()

复制代码

在这个示例中，我们定义了一个`MyRunnable`类，该类继承自`QRunnable`。在`run()`方法中编写了耗时的任务代码，并通过`finished`信号发射任务的结果。窗口B中的按钮方法`start_thread()`会创建并配置任务对象，然后将任务提交给线程池启动执行。当任务完成时，会触发信号`finished`，并在`on_operation_finished()`方法中处理任务的结果。

使用`QThreadPool`可以自动管理和调度多个任务的线程池，避免手动管理线程的复杂性。通过将任务对象提交给线程池，可以简化多线程的使用。希望这个解决方案能够帮助到你，如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yxxxzx123

FishC 发表于 2024-3-15 09:17
如果你的窗口A已经关闭，并且所有的按钮和相关方法都在窗口B中，那么你可以将线程类定义在窗口B中，以 ...

那如果B窗体中有多个按钮、多个方法，又要怎么写呢?

麻烦示范一下。

FishC

yxxxzx123 发表于 2024-03-15 09:40
那如果B窗体中有多个按钮、多个方法，又要怎么写呢?
...

如果窗口B中有多个按钮和多个方法，每个方法都需要在独立的线程中执行耗时任务，可以为每个按钮创建一个对应的槽函数，在槽函数中启动对应的线程来处理任务。以下是一个示例：from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QPushButton, QLabelfrom PySide6.QtCore import QRunnable, QObject, Signal, Qt, QThreadPoolimport timeclass MyRunnable(QRunnable):    def __init__(self, task_name):        super().__init__()        self.task_name = task_name        self.setAutoDelete(True)    def run(self):        # 模拟耗时任务        time.sleep(3)        print(f"{self.task_name} 任务完成")        self.finished.emit()    finished = Signal()class WindowB(QMainWindow):    def __init__(self):        super().__init__()        self.threadpool = QThreadPool()                self.label = QLabel("进度条")        self.button1 = QPushButton("任务1")        self.button2 = QPushButton("任务2")        self.button1.clicked.connect(lambda: self.start_thread("任务1"))        self.button2.clicked.connect(lambda: self.start_thread("任务2"))        layout = QVBoxLayout()        layout.addWidget(self.label)        layout.addWidget(self.button1)        layout.addWidget(self.button2)        central_widget = QWidget()        central_widget.setLayout(layout)        self.setCentralWidget(central_widget)    def start_thread(self, task_name):        # 创建并配置任务对象        runnable = MyRunnable(task_name)        runnable.finished.connect(self.on_operation_finished)                # 将任务提交给线程池        self.threadpool.start(runnable)    def on_operation_finished(self):        # 在这里处理任务完成的操作        print("任务完成")app = QApplication()window_b = WindowB()window_b.show()app.exec()在这个示例中，我们为窗口B中的每个按钮创建了一个对应的槽函数，并通过`lambda`表达式将任务名称作为参数传递给`start_thread()`方法。`start_thread()`方法会根据任务名称创建并配置任务对象，并将任务提交给线程池。当任务完成时，会触发信号`finished`，在`on_operation_finished()`方法中处理任务的完成操作。通过这种方式，可以灵活地为窗口B中的多个按钮和方法启动不同的线程来执行耗时任务。希望这个示例能够解决你的问题，如果还有其他疑问，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

清風

FishC 发表于 2024-3-15 09:41
如果窗口B中有多个按钮和多个方法，每个方法都需要在独立的线程中执行耗时任务，可以为每个按钮创建一 ...

回复请注意python格式

清風

FishC 发表于 2024-3-15 09:41
如果窗口B中有多个按钮和多个方法，每个方法都需要在独立的线程中执行耗时任务，可以为每个按钮创建一 ...

回复请注意python格式

yxxxzx123

FishC 发表于 2024-3-15 09:41
如果窗口B中有多个按钮和多个方法，每个方法都需要在独立的线程中执行耗时任务，可以为每个按钮创建一 ...

回复请注意python格式  麻烦也带上代码说明

FishC

yxxxzx123 发表于 2024-03-15 09:51
回复请注意python格式  麻烦也带上代码说明

非常抱歉，以下是使用Python格式的示例代码和详细说明：

1. from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QPushButton, QLabel
   
2. from PySide6.QtCore import QRunnable, QObject, Signal, Qt, QThreadPool
   
3. import time
   
4. 
   
5. class MyRunnable(QRunnable):
   
6.     def __init__(self, task_name):
   
7.         super().__init__()
   
8.         self.task_name = task_name
   
9.         self.setAutoDelete(True)
   
10. 
    
11.     def run(self):
    
12.         # 模拟耗时任务
    
13.         time.sleep(3)
    
14.         print(f"{self.task_name} 任务完成")
    
15.         self.finished.emit()
    
16. 
    
17.     finished = Signal()
    
18. 
    
19. class WindowB(QMainWindow):
    
20.     def __init__(self):
    
21.         super().__init__()
    
22.         self.threadpool = QThreadPool()
    
23.         
    
24.         self.label = QLabel("进度条")
    
25.         self.button1 = QPushButton("任务1")
    
26.         self.button2 = QPushButton("任务2")
    
27.         
    
28.         self.button1.clicked.connect(lambda: self.start_thread("任务1"))
    
29.         self.button2.clicked.connect(lambda: self.start_thread("任务2"))
    
30.         
    
31.         layout = QVBoxLayout()
    
32.         layout.addWidget(self.label)
    
33.         layout.addWidget(self.button1)
    
34.         layout.addWidget(self.button2)
    
35.         
    
36.         central_widget = QWidget()
    
37.         central_widget.setLayout(layout)
    
38.         self.setCentralWidget(central_widget)
    
39. 
    
40.     def start_thread(self, task_name):
    
41.         # 创建并配置任务对象
    
42.         runnable = MyRunnable(task_name)
    
43.         runnable.finished.connect(self.on_operation_finished)
    
44. 
    
45.         # 将任务提交给线程池
    
46.         self.threadpool.start(runnable)
    
47. 
    
48.     def on_operation_finished(self):
    
49.         # 在这里处理任务完成的操作
    
50.         print("任务完成")
    
51. 
    
52. app = QApplication()
    
53. window_b = WindowB()
    
54. window_b.show()
    
55. app.exec()

复制代码

在这个示例中，我们创建了一个自定义的线程类`MyRunnable`，继承自`QRunnable`。在`MyRunnable`中，我们重写了`run()`方法，用于执行耗时任务。这里使用`time.sleep(3)`模拟了一个耗时3秒的任务。当任务完成后，通过发射信号`finished`来通知主线程。

在`WindowB`类中，我们创建了多个按钮和一个标签。为了演示不同按钮启动不同的线程，我们为每个按钮连接了对应的槽函数。在槽函数中，我们创建并配置了任务对象，并将任务提交给线程池进行执行。当任务完成时，会触发信号`finished`，在`on_operation_finished()`方法中处理任务完成的操作。

最后，我们创建了应用程序对象，实例化了窗口B并显示出来。

希望这个示例能够解决你的问题，如果还有其他疑问，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

清風

AI不理我，真麻烦，要反复换号来问。。。

清風

FishC 发表于 2024-3-15 09:51
非常抱歉，以下是使用Python格式的示例代码和详细说明：

我没看懂，得慢慢消化。。。