暂停和恢复qthread

Question

我正在使用python，pyqt5，qthread。

我有一个GUI，它显示图片并使用“继续”按钮更改它们。

我想达到的东西： 在另一个选项卡中，我有一个按钮“开始”。

按下“启动”按钮时，假设应预处理8个图片（更改了一个尺寸的大小）。 每次点击“继续”时，应显示一张图片，应预处理另一个新图片，并应删除第一张图片（qpixmap对象）。

因此，第一次运行将是： 图1-8预处理 图片1显示

第二次运行： 图9预处理 显示图2

为了不冻结GUI，我需要在这里线程。我的想法是在第一次运行中进行8张图片后，然后在每张预处理的图片中停止此线程，但永远不要破坏该过程。

您将如何意识到此线程暂停？

这样做的主要问题是，如果某人在“继续”上单击太快（示例：图片9仍在预处理中，但它已经试图开始对图片10进行预处理，但是我只想将图片10添加到图片中，以进行预处理，并且不要停止一些东西...）

您能帮我吗？

Answer 1

一般而言，您通常不需要“暂停”线程，而是根据所需的预紧计数正确 queue 。然后，该线程将“暂停”本身，但这仅仅是因为它正在等待新对象处理。

假设处理是始终顺序的，并且在一个方向上（不回到上一个图像），可能的解决方案是始终排队n + preload-count eyt时间显示新图像。

from queue import Queue
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *

class Loader(QThread):
    imageReady = pyqtSignal(int, QImage)
    def __init__(self):
        super().__init__()
        self.queue = Queue()

    def run(self):
        self.keepRunning = True
        while self.keepRunning:
            index, path = self.queue.get()
            image = QImage(path)
            # simulate long processing
            self.msleep(image.width() + image.height())
            result = image.scaled(600, 600, Qt.KeepAspectRatio)
            self.imageReady.emit(index, result)

    def process(self, index, path):
        self.queue.put((index, path))

    def stop(self):
        self.keepRunning = False
        self.wait()


class LinearImageProcess(QWidget):
    cacheSize = 10
    currentIndex = -1
    def __init__(self):
        super().__init__()
        layout = QVBoxLayout(self)
        self.startButton = QPushButton('Start')
        self.continueButton = QPushButton('Continue', enabled=False)
        self.view = QLabel()
        self.view.setAlignment(Qt.AlignCenter)
        self.view.setFixedSize(600, 600)
        layout.addWidget(self.startButton)
        layout.addWidget(self.continueButton)
        layout.addWidget(self.view)

        self.fileList = tuple(enumerate(
            QDir(QDir.tempPath()).entryList(['*.jpg', '*.png'])))
        self.cache = []
        self.loader = Loader()
        self.loader.start()
        self.loader.imageReady.connect(self.imageReady)

        self.startButton.clicked.connect(self.start)
        self.continueButton.clicked.connect(self.showNext)

    def start(self):
        self.startButton.setEnabled(False)
        self.currentIndex = 0
        for i, file in self.fileList[:self.cacheSize]:
            self.loader.process(i, file)

    def showNext(self):
        if self.cache:
            self.view.setPixmap(self.cache.pop(0))
        else:
            self.continueButton.setEnabled(False)
        nextIndex = self.currentIndex + 1
        if nextIndex < len(self.fileList):
            self.currentIndex = nextIndex
        nextProcess = self.currentIndex + self.cacheSize
        if nextProcess < len(self.fileList):
            self.loader.process(*self.fileList[nextProcess])

    def imageReady(self, index, image):
        pm = QPixmap.fromImage(image)
        if self.currentIndex == index:
            self.view.setPixmap(pm)
            self.continueButton.setEnabled(self.currentIndex < len(self.fileList))
        else:
            self.cache.append(pm)
            self.continueButton.setEnabled(True)
        if self.continueButton.isEnabled():
            self.continueButton.setFocus()


app = QApplication([])
w = LinearImageProcess()
w.show()
app.exec()

相反，如果您想在两个方向上提供浏览/处理，那么事情变得有些棘手：问题是线程队列在处理时可能需要更改，因为用户已更改了浏览方向（甚至跳到另一个索引）。

一个可能的解决方案是为UI实施进一步的队列，以取决于当前索引。仅当从线程中收到新图像，然后仅基于当前索引排列下一个进程请求时，就会导致UI线程要求新进程。这种方法的一个好处是，即使在上面使用的更简单的“线性”方向上，它显然可以起作用。

class NonLinearImageProcess(QWidget):
    cacheSize = 20
    _currentIndex = -1
    def __init__(self):
        super().__init__()
        layout = QVBoxLayout(self)
        self.startButton = QPushButton('Start')

        self.browseWidget = QWidget(enabled=False)
        browseLayout = QHBoxLayout(self.browseWidget)
        browseLayout.setContentsMargins(0, 0, 0, 0)
        style = self.style()
        self.beginButton = QToolButton(
            icon=style.standardIcon(style.SP_MediaSkipBackward))
        self.backButton = QToolButton(
            icon=style.standardIcon(style.SP_ArrowLeft))
        self.imageSpin = QSpinBox(keyboardTracking=False)
        self.forwardButton = QToolButton(
            icon=style.standardIcon(style.SP_ArrowRight))
        self.endButton = QToolButton(
            icon=style.standardIcon(style.SP_MediaSkipForward))
        
        browseLayout.addWidget(self.beginButton)
        browseLayout.addWidget(self.backButton)
        browseLayout.addWidget(self.imageSpin)
        browseLayout.addWidget(self.forwardButton)
        browseLayout.addWidget(self.endButton)

        self.view = QLabel()
        self.view.setAlignment(Qt.AlignCenter)
        self.view.setFixedSize(600, 600)

        layout.addWidget(self.startButton)
        layout.addWidget(self.browseWidget)
        layout.addWidget(self.view, alignment=Qt.AlignCenter)

        self.fileList = tuple(enumerate(
            QDir(QDir.tempPath()).entryList(['*.jpg', '*.png'])))
        self.imageSpin.setRange(1, len(self.fileList))
        self.imageSpin.setSuffix(' of {}'.format(len(self.fileList)))

        self.cache = {}
        self.loadQueue = []
        self.loader = Loader()
        self.loader.start()
        self.loader.imageReady.connect(self.imageReady)
        self.goToTimer = QTimer(self, singleShot=True, 
            interval=100, timeout=self.goTo)

        self.startButton.clicked.connect(self.start)
        self.beginButton.clicked.connect(self.goToStart)
        self.backButton.clicked.connect(self.goToPrevious)
        self.forwardButton.clicked.connect(self.goToNext)
        self.endButton.clicked.connect(self.goToEnd)
        # the lambda is required since valueChanged sends an integer argument
        # that would be used as interval for start()
        self.imageSpin.valueChanged.connect(lambda: self.goToTimer.start())

        self.setMaximumSize(self.sizeHint())

    @pyqtProperty(int)
    def currentIndex(self):
        return self._currentIndex

    @currentIndex.setter
    def currentIndex(self, index):
        if index < 0:
            index = 0
        maxIndex = len(self.fileList) - 1
        if index > maxIndex:
            index = maxIndex
        if self._currentIndex == index:
            return

        self._currentIndex = index
        canGoBack = index > 0
        self.beginButton.setEnabled(canGoBack)
        self.backButton.setEnabled(canGoBack)
        canGoForward = index < maxIndex
        self.forwardButton.setEnabled(canGoForward)
        self.endButton.setEnabled(canGoForward)

    def start(self):
        self.startButton.setEnabled(False)
        if not self.fileList:
            return
        self.currentIndex = 0
        self.loader.process(*self.fileList[0])
        for i, file in self.fileList[1:self.cacheSize // 2]:
            self.loadQueue.append(i)

    def goTo(self, index=None):
        if index is None:
            index = self.imageSpin.value() - 1
        oldIndex = self.currentIndex
        self.currentIndex = index
        if oldIndex == self.currentIndex:
            return

        pm = self.cache.get(index)
        if isinstance(pm, QPixmap):
            self.view.setPixmap(self.cache[index])
            self.browseWidget.setEnabled(True)
            self.imageSpin.setFocus()
            with QSignalBlocker(self.imageSpin):
                self.imageSpin.setValue(index + 1)
        else:
            self.browseWidget.setEnabled(False)

        partCacheSize = self.cacheSize // 2
        start = max(0, index - partCacheSize)
        end = min(index + partCacheSize + 1, len(self.fileList))
        for i in range(start):
            if isinstance(self.cache.get(i), QPixmap):
                self.cache.pop(i)
        for i in range(end, len(self.fileList)):
            if isinstance(self.cache.get(i), QPixmap):
                self.cache.pop(i)
        
        self.loadQueue.clear()
        # try to equally process images from both "edges" of the queue: i.e. if
        # the current index is 30, queue indexes 31, 29, 32, 28, etc.
        for pair in zip_longest(range(index - 1, start - 1, -1), range(index, end)):
            for i in pair:
                if (i is not None and i not in self.cache):
                    self.loadQueue.append(i)
        self.processNextInQueue()

    def processNextInQueue(self):
        if self.loadQueue:
            nextIndex = self.loadQueue.pop(0)
            self.loader.process(*self.fileList[nextIndex])

    def goToStart(self):
        self.goTo(0)

    def goToPrevious(self):
        self.goTo(self.currentIndex - 1)

    def goToNext(self):
        self.goTo(self.currentIndex + 1)

    def goToEnd(self):
        self.goTo(len(self.fileList) - 1)

    def imageReady(self, index, image):
        pm = QPixmap.fromImage(image)
        self.cache[index] = pm
        if self.currentIndex == index:
            self.view.setPixmap(pm)
            self.browseWidget.setEnabled(True)
            self.imageSpin.setFocus()
            with QSignalBlocker(self.imageSpin):
                self.imageSpin.setValue(index + 1)
        if index in self.loadQueue:
            self.loadQueue.remove(index)
        self.processNextInQueue()