试图让 QProcess 与队列一起工作 [英] Trying to get QProcess to work with a queue
问题描述
我正在尝试使用队列运行多个进程并使用 QProcess 获取所有进程的输出，但我遇到了一些问题.我正在使用 QSpinBox 来设置同时运行的最大进程数，我可以在主线程中使一切正常运行，或者如果我在 QObject<中使用进程运行循环/code> 但我无法让它在 QThread 中正常工作.
我知道没有必要将线程与 QProcess 一起使用，但是对于循环，我几乎别无选择.在主线程中运行时，它会暂时冻结，直到进程启动，我希望它运行得更顺畅.
除非我使用类似 _process.waitForFinished() 之类的东西，否则我在尝试运行 QThread 中的进程时只会出错，但问题是进程一次只运行一个.
有没有人有任何建议可以使其正常工作?我目前正在使用 Pyside2，但是 Pyside2 或 PyQt5 的答案就可以了.谢谢.
I am trying to run several processes with a queue and get the output for all processes using QProcess but I am having a couple of issues. I am using a QSpinBox to set the max processes to run at the same time and I can get everything working fine in the main thread or if I run the loop with the processes in a QObject but I am unable to get it to work properly in a QThread.
I know there is no need for using threads with QProcess but with the loop I pretty much have no choice. When ran in the main thread it freezes momentarily until the processes start and I'd rather have it run smoother.
I get nothing but errors trying to run the processes in QThread unless I use something like _process.waitForFinished() but the problem with that is the processes only run one at a time.
Does anyone have any suggestions to get this working properly? I am currently using Pyside2 but an answer for Pyside2 or PyQt5 would be fine. Thanks.
import queue
import sys
from PySide2.QtCore import QProcess, QTextCodec, QThread, Qt
from PySide2.QtWidgets import QApplication, QWidget, QSpinBox, \
QPushButton, QVBoxLayout
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.queue = queue.Queue()
layout = QVBoxLayout(self)
self.startBtn = QPushButton('Start', clicked=self.addToQueue)
self.spinBox = QSpinBox(value=3)
layout.addWidget(self.spinBox)
layout.addWidget(self.startBtn)
self.taskList = ['my.exe -value','my.exe -value','my.exe -value','my.exe -value',
'my.exe -value','my.exe -value','my.exe -value','my.exe -value']
def addToQueue(self):
for i in self.taskList:
self.queue.put(i)
self.sendToThread()
def sendToThread(self):
vals = {'max': self.spinBox.value()}
self.taskThread = TaskThread(self.queue, vals)
self.taskThread.start()
def closeEvent(self, event):
event.accept()
class TaskThread(QThread):
def __init__(self, queue=None, vals=None, parent=None):
QThread.__init__(self, parent)
self.queue = queue
self.vals = vals
self.maxProcs = self.vals.get('max')
self.procCount = 0
def run(self):
self.start_procs()
def start_procs(self):
while not self.queue.empty() and self.procCount < self.maxProcs:
cmd = self.queue.get()
_process = QProcess(self)
_process.setProcessChannelMode(QProcess.MergedChannels)
self.codec = QTextCodec.codecForLocale()
self._decoder_stdout = self.codec.makeDecoder()
_process.readyReadStandardOutput.connect(lambda process=_process: self._ready_read_standard_output(process))
_process.started.connect(self.procStarted)
_process.finished.connect(self.procFinished)
_process.finished.connect(self.decreaseCount)
_process.finished.connect(self.start_procs)
_process.start(cmd)
self.procCount += 1
def _ready_read_standard_output(self, process):
self.out = process.readAllStandardOutput()
self.text = self._decoder_stdout.toUnicode(self.out)
print(self.text)
def decreaseCount(self):
if self.procCount <= 0:
pass
else:
self.procCount -= 1
def procStarted(self):
print('started')
def procFinished(self):
print('finished')
if __name__ == '__main__':
app = QApplication(sys.argv)
window = Window()
window.resize(200, 100)
window.show()
sys.exit(app.exec_())
推荐答案
当你启动一个进程并不意味着它启动了，因为它可能有执行问题，所以在第一次启动时最好等待进程启动启动或启动以下进程失败，满足正在运行的进程数小于最大值或不再执行任务或尚未启动的要求.
When you launch a process it does not mean that it started because it can have execution problems, so in the first launch it is better to wait for the process to be started or failed to launch the following process, fulfilling the requirements that the number of processes is running is less than the maximum or no longer do tasks or has not started.
另一方面我也实现了停止任务，这意味着不再添加任务，而是继续执行停止前正在执行的任务.
On the other hand I have also implemented the task of stopping, which implies that no more tasks will be added but the tasks that were being executed before stopping will continue to be executed.
如果您将最大值更改为较低的值，则在满足条件之前不会再抛出更多任务.
If you change the maxvalue to a lower value then no more tasks will be thrown until the condition is met.
综上所述，没有必要使用线程
Considering the above, it is not necessary to use threads
import queue
from PySide2 import QtCore, QtGui, QtWidgets
class TaskManager(QtCore.QObject):
messageChanged = QtCore.Signal(str)
numbersTaskRunningChanged = QtCore.Signal(int)
def __init__(self, parent=None):
super(TaskManager, self).__init__(parent)
self._max_task = 1
self._queue = queue.Queue()
self._numbers_task_running = 0
self._running = False
def setMaxTask(self, max_task):
self._max_task = max_task
if self._running:
self.call_task()
def maxTask(self):
return self._max_task
def appendTask(self, task):
self._queue.put(task)
self.call_task()
def start(self):
self._running = True
self.call_task()
def stop(self):
self._running = False
def call_task(self):
if self._numbers_task_running < self.maxTask() and not self._queue.empty() and self._running:
cmd = self._queue.get()
process = QtCore.QProcess(self)
process.setProcessChannelMode(QtCore.QProcess.MergedChannels)
process.readyReadStandardOutput.connect(self.on_readyReadStandardOutput)
process.finished.connect(self.on_finished)
process.started.connect(self.on_started)
process.errorOccurred.connect(self.on_errorOccurred)
process.start(cmd)
def on_readyReadStandardOutput(self):
codec = QtCore.QTextCodec.codecForLocale()
decoder_stdout = codec.makeDecoder()
process = self.sender()
text = decoder_stdout.toUnicode(process.readAllStandardOutput())
self.messageChanged.emit(text)
def on_errorOccurred(self, error):
process = self.sender()
print("error: ", error, "-", " ".join([process.program()] + process.arguments()))
self.call_task()
def on_finished(self):
process = self.sender()
self._numbers_task_running -= 1
self.numbersTaskRunningChanged.emit(self._numbers_task_running)
self.call_task()
def on_started(self):
process = self.sender()
print("started: ", " ".join([process.program()] + process.arguments()))
self._numbers_task_running += 1
self.numbersTaskRunningChanged.emit(self._numbers_task_running)
self.call_task()
class Widget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(Widget, self).__init__(parent)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
manager = TaskManager(self)
task_list = # ...
for task in task_list:
manager.appendTask(task)
button_start = QtWidgets.QPushButton("Start", clicked=manager.start)
button_stop = QtWidgets.QPushButton("Stop", clicked=manager.stop)
label = QtWidgets.QLabel("0", alignment=QtCore.Qt.AlignCenter)
manager.numbersTaskRunningChanged.connect(label.setNum)
spinBox = QtWidgets.QSpinBox()
spinBox.valueChanged.connect(manager.setMaxTask)
spinBox.setValue(3)
textEdit = QtWidgets.QTextEdit()
manager.messageChanged.connect(textEdit.append)
lay = QtWidgets.QVBoxLayout(self)
lay.addWidget(spinBox)
lay.addWidget(button_start)
lay.addWidget(button_stop)
lay.addWidget(label)
lay.addWidget(textEdit)
if __name__ == '__main__':
import sys
app = QtWidgets.QApplication(sys.argv)
w = Widget()
w.show()
sys.exit(app.exec_())
这篇关于试图让 QProcess 与队列一起工作的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
