entityMap|blocks|key|egn3u|text|我创建了一个小示例，展示了处理线程的三种不同且简单的方法。我希望它能帮助你找到解决问题的正确方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

I created a little example that shows 3 different and simple ways of dealing with threads. I hope it will help you find the right approach to your problem.

<pre><code>import sys
import time

from PyQt5.QtCore import (QCoreApplication, QObject, QRunnable, QThread,
 QThreadPool, pyqtSignal)


# Subclassing QThread
# http://qt-project.org/doc/latest/qthread.html
class AThread(QThread):

 def run(self):
 count = 0
 while count &lt; 5:
 time.sleep(1)
 print("A Increasing")
 count += 1

# Subclassing QObject and using moveToThread
# http://blog.qt.digia.com/blog/2007/07/05/qthreads-no-longer-abstract
class SomeObject(QObject):

 finished = pyqtSignal()

 def long_running(self):
 count = 0
 while count &lt; 5:
 time.sleep(1)
 print("B Increasing")
 count += 1
 self.finished.emit()

# Using a QRunnable
# http://qt-project.org/doc/latest/qthreadpool.html
# Note that a QRunnable isn't a subclass of QObject and therefore does
# not provide signals and slots.
class Runnable(QRunnable):

 def run(self):
 count = 0
 app = QCoreApplication.instance()
 while count &lt; 5:
 print("C Increasing")
 time.sleep(1)
 count += 1
 app.quit()


def using_q_thread():
 app = QCoreApplication([])
 thread = AThread()
 thread.finished.connect(app.exit)
 thread.start()
 sys.exit(app.exec_())

def using_move_to_thread():
 app = QCoreApplication([])
 objThread = QThread()
 obj = SomeObject()
 obj.moveToThread(objThread)
 obj.finished.connect(objThread.quit)
 objThread.started.connect(obj.long_running)
 objThread.finished.connect(app.exit)
 objThread.start()
 sys.exit(app.exec_())

def using_q_runnable():
 app = QCoreApplication([])
 runnable = Runnable()
 QThreadPool.globalInstance().start(runnable)
 sys.exit(app.exec_())

if __name__ == "__main__":
 #using_q_thread()
 #using_move_to_thread()
 using_q_runnable()
</code></pre>

entityMap|blocks|key|au6uf|text|请接受为PyQt5，Python3.4更新的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2nb1u|使用此模式启动一个worker，该worker不接受数据并在表单可用时返回数据。|eg548|1-+Worker类变得更小，放在自己的文件worker.py中，便于记忆和独立的软件重用。|8v1jd|2-+main.py文件是定义图形用户界面窗体类的文件|ar2lv|3-线程对象没有子类化。|fnkuh|4-线程对象和worker对象都属于Form对象|9s16h|5-程序的步骤在注释中。|ee4f3|主文件是：^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Q|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|R|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|S|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|T|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|U|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|V|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|W|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|X|9|@]|A|@]|B|$]]]]

Take this answer updated for PyQt5, python 3.4 

Use this as a pattern to start a worker that does not take data and return data as they are available to the form.

1 - Worker class is made smaller and put in its own file worker.py for easy memorization and independent software reuse.

2 - The main.py file is the file that defines the GUI Form class

3 - The thread object is not subclassed.

4 - Both thread object and the worker object belong to the Form object

5 - Steps of the procedure are within the comments.

<pre><code># worker.py
from PyQt5.QtCore import QThread, QObject, pyqtSignal, pyqtSlot
import time


class Worker(QObject):
 finished = pyqtSignal()
 intReady = pyqtSignal(int)


 @pyqtSlot()
 def procCounter(self): # A slot takes no params
 for i in range(1, 100):
 time.sleep(1)
 self.intReady.emit(i)

 self.finished.emit()
</code></pre>

And the main file is:

<pre><code> # main.py
 from PyQt5.QtCore import QThread
 from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout
 import sys
 import worker


 class Form(QWidget):

 def __init__(self):
 super().__init__()
 self.label = QLabel("0")

 # 1 - create Worker and Thread inside the Form
 self.obj = worker.Worker() # no parent!
 self.thread = QThread() # no parent!

 # 2 - Connect Worker`s Signals to Form method slots to post data.
 self.obj.intReady.connect(self.onIntReady)

 # 3 - Move the Worker object to the Thread object
 self.obj.moveToThread(self.thread)

 # 4 - Connect Worker Signals to the Thread slots
 self.obj.finished.connect(self.thread.quit)

 # 5 - Connect Thread started signal to Worker operational slot method
 self.thread.started.connect(self.obj.procCounter)

 # * - Thread finished signal will close the app if you want!
 #self.thread.finished.connect(app.exit)

 # 6 - Start the thread
 self.thread.start()

 # 7 - Start the form
 self.initUI()


 def initUI(self):
 grid = QGridLayout()
 self.setLayout(grid)
 grid.addWidget(self.label,0,0)

 self.move(300, 150)
 self.setWindowTitle('thread test')
 self.show()

 def onIntReady(self, i):
 self.label.setText("{}".format(i))
 #print(i)

 app = QApplication(sys.argv)

 form = Form()

 sys.exit(app.exec_())
</code></pre>

entityMap|blocks|key|e7prf|text|来自Matt的非常好的示例，我修复了拼写错误，并且pyqt4.8现在很常见，所以我也删除了虚拟类，并为dataReady信号添加了一个示例|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Very nice example from Matt, I fixed the typo and also pyqt4.8 is common now so I removed the dummy class as well and added an example for the dataReady signal

<pre><code># -*- coding: utf-8 -*-
import sys
from PyQt4 import QtCore, QtGui
from PyQt4.QtCore import Qt


# very testable class (hint: you can use mock.Mock for the signals)
class Worker(QtCore.QObject):
 finished = QtCore.pyqtSignal()
 dataReady = QtCore.pyqtSignal(list, dict)

 @QtCore.pyqtSlot()
 def processA(self):
 print "Worker.processA()"
 self.finished.emit()

 @QtCore.pyqtSlot(str, list, list)
 def processB(self, foo, bar=None, baz=None):
 print "Worker.processB()"
 for thing in bar:
 # lots of processing...
 self.dataReady.emit(['dummy', 'data'], {'dummy': ['data']})
 self.finished.emit()


def onDataReady(aList, aDict):
 print 'onDataReady'
 print repr(aList)
 print repr(aDict)


app = QtGui.QApplication(sys.argv)

thread = QtCore.QThread() # no parent!
obj = Worker() # no parent!
obj.dataReady.connect(onDataReady)

obj.moveToThread(thread)

# if you want the thread to stop after the worker is done
# you can always call thread.start() again later
obj.finished.connect(thread.quit)

# one way to do it is to start processing as soon as the thread starts
# this is okay in some cases... but makes it harder to send data to
# the worker object from the main gui thread. As you can see I'm calling
# processA() which takes no arguments
thread.started.connect(obj.processA)
thread.finished.connect(app.exit)

thread.start()

# another way to do it, which is a bit fancier, allows you to talk back and
# forth with the object in a thread safe way by communicating through signals
# and slots (now that the thread is running I can start calling methods on
# the worker object)
QtCore.QMetaObject.invokeMethod(obj, 'processB', Qt.QueuedConnection,
 QtCore.Q_ARG(str, "Hello World!"),
 QtCore.Q_ARG(list, ["args", 0, 1]),
 QtCore.Q_ARG(list, []))

# that looks a bit scary, but its a totally ok thing to do in Qt,
# we're simply using the system that Signals and Slots are built on top of,
# the QMetaObject, to make it act like we safely emitted a signal for
# the worker thread to pick up when its event loop resumes (so if its doing
# a bunch of work you can call this method 10 times and it will just queue
# up the calls. Note: PyQt &gt; 4.6 will not allow you to pass in a None
# instead of an empty list, it has stricter type checking

app.exec_()
</code></pre>

entityMap|blocks|key|96qka|text|根据Qt开发人员的说法，子类化QThread是不正确的(请参阅http://blog.qt.io/blog/2010/06/17/youre-doing-it-wrong/).但这篇文章真的很难理解(加上标题有点居高临下)。我找到了一篇更好的博客文章，它更详细地解释了为什么应该使用一种线程样式而不是另一种样式:+http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/|type|unstyled|depth|inlineStyleRanges|entityRanges|data|akrgq|在我看来，你可能永远不应该为了重载run方法而子类化thread。虽然这确实有效，但您基本上是在绕过Qt希望您工作的方式。此外，您还会错过事件、适当的线程安全信号和插槽等内容。另外，正如你可能在上面的博客文章中看到的那样，“正确”的线程化方式迫使你编写更多可测试的代码。|cc06b|这里有几个如何在PyQt中利用QThreads的例子(我在下面发布了一个单独的答案，它正确地使用了QRunnable并合并了信号/插槽，如果你有很多需要负载平衡的异步任务，这个答案会更好)。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

According to the Qt developers, subclassing QThread is incorrect (see <a href="http://blog.qt.io/blog/2010/06/17/youre-doing-it-wrong/" rel="noreferrer">http://blog.qt.io/blog/2010/06/17/youre-doing-it-wrong/</a>). But that article is really hard to understand (plus the title is a bit condescending). I found a better blog post that gives a more detailed explanation about why you should use one style of threading over another: <a href="http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/" rel="noreferrer">http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/</a> 

In my opinion, you should probably never subclass thread with the intent to overload the run method. While that does work, you're basically circumventing how Qt wants you to work. Plus you'll miss out on things like events and proper thread safe signals and slots. Plus as you'll likely see in the above blog post, the "correct" way of threading forces you to write more testable code.

Here's a couple of examples of how to take advantage of QThreads in PyQt (I posted a separate answer below that properly uses QRunnable and incorporates signals/slots, that answer is better if you have a lot of async tasks that you need to load balance).

<pre><code>import sys
from PyQt4 import QtCore
from PyQt4 import QtGui
from PyQt4.QtCore import Qt

# very testable class (hint: you can use mock.Mock for the signals)
class Worker(QtCore.QObject):
 finished = QtCore.pyqtSignal()
 dataReady = QtCore.pyqtSignal(list, dict)

 @QtCore.pyqtSlot()
 def processA(self):
 print "Worker.processA()"
 self.finished.emit()

 @QtCore.pyqtSlot(str, list, list)
 def processB(self, foo, bar=None, baz=None):
 print "Worker.processB()"
 for thing in bar:
 # lots of processing...
 self.dataReady.emit(['dummy', 'data'], {'dummy': ['data']})
 self.finished.emit()


class Thread(QtCore.QThread):
 """Need for PyQt4 &lt;= 4.6 only"""
 def __init__(self, parent=None):
 QtCore.QThread.__init__(self, parent)

 # this class is solely needed for these two methods, there
 # appears to be a bug in PyQt 4.6 that requires you to
 # explicitly call run and start from the subclass in order
 # to get the thread to actually start an event loop

 def start(self):
 QtCore.QThread.start(self)

 def run(self):
 QtCore.QThread.run(self)


app = QtGui.QApplication(sys.argv)

thread = Thread() # no parent!
obj = Worker() # no parent!
obj.moveToThread(thread)

# if you want the thread to stop after the worker is done
# you can always call thread.start() again later
obj.finished.connect(thread.quit)

# one way to do it is to start processing as soon as the thread starts
# this is okay in some cases... but makes it harder to send data to
# the worker object from the main gui thread. As you can see I'm calling
# processA() which takes no arguments
thread.started.connect(obj.processA)
thread.start()

# another way to do it, which is a bit fancier, allows you to talk back and
# forth with the object in a thread safe way by communicating through signals
# and slots (now that the thread is running I can start calling methods on
# the worker object)
QtCore.QMetaObject.invokeMethod(obj, 'processB', Qt.QueuedConnection,
 QtCore.Q_ARG(str, "Hello World!"),
 QtCore.Q_ARG(list, ["args", 0, 1]),
 QtCore.Q_ARG(list, []))

# that looks a bit scary, but its a totally ok thing to do in Qt,
# we're simply using the system that Signals and Slots are built on top of,
# the QMetaObject, to make it act like we safely emitted a signal for 
# the worker thread to pick up when its event loop resumes (so if its doing
# a bunch of work you can call this method 10 times and it will just queue
# up the calls. Note: PyQt &gt; 4.6 will not allow you to pass in a None
# instead of an empty list, it has stricter type checking

app.exec_()

# Without this you may get weird QThread messages in the shell on exit
app.deleteLater() 
</code></pre>

entityMap|blocks|key|70ooq|text|在PyQt中，有很多获取异步行为的选项。对于需要事件处理的东西(即，QtNetwork等)你应该在这个帖子上使用我在另一个答案中提供的QThread示例。但是对于绝大多数的线程需求，我认为这个解决方案比其他方法要好得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|q6jr|这样做的好处是QThreadPool将您的QRunnable实例调度为任务。这类似于英特尔TBB中使用的任务模式。它不像我喜欢的那样优雅，但它确实实现了出色的异步行为。|bu6g2|这允许您通过QRunnable在Python中使用Qt的大部分线程功能，同时仍然利用信号和插槽。我在几个应用程序中使用了相同的代码，一些应用程序进行了数百次异步REST调用，一些应用程序打开文件或列出目录，最好的部分是使用这种方法，Qt任务为我平衡了系统资源。|aq6to|退出应用程序时，您需要确保取消了所有任务，否则应用程序将挂起，直到每个计划任务完成^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|K|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|L|9|@]|A|@]|B|$]]]]

In PyQt there are a lot of options for getting asynchronous behavior. For things that need event processing (ie. QtNetwork, etc) you should use the QThread example I provided in my other answer on this thread. But for the vast majority of your threading needs, I think this solution is far superior than the other methods.

The advantage of this is that the QThreadPool schedules your QRunnable instances as tasks. This is similar to the task pattern used in Intel's TBB. It's not quite as elegant as I like but it does pull off excellent asynchronous behavior.

This allows you to utilize most of the threading power of Qt in Python via QRunnable and still take advantage of signals and slots. I use this same code in several applications, some that make hundreds of asynchronous REST calls, some that open files or list directories, and the best part is using this method, Qt task balances the system resources for me.

<pre><code>import time
from PyQt4 import QtCore
from PyQt4 import QtGui
from PyQt4.QtCore import Qt


def async(method, args, uid, readycb, errorcb=None):
 """
 Asynchronously runs a task

 :param func method: the method to run in a thread
 :param object uid: a unique identifier for this task (used for verification)
 :param slot updatecb: the callback when data is receieved cb(uid, data)
 :param slot errorcb: the callback when there is an error cb(uid, errmsg)

 The uid option is useful when the calling code makes multiple async calls
 and the callbacks need some context about what was sent to the async method.
 For example, if you use this method to thread a long running database call
 and the user decides they want to cancel it and start a different one, the
 first one may complete before you have a chance to cancel the task. In that
 case, the "readycb" will be called with the cancelled task's data. The uid
 can be used to differentiate those two calls (ie. using the sql query).

 :returns: Request instance
 """
 request = Request(method, args, uid, readycb, errorcb)
 QtCore.QThreadPool.globalInstance().start(request)
 return request


class Request(QtCore.QRunnable):
 """
 A Qt object that represents an asynchronous task

 :param func method: the method to call
 :param list args: list of arguments to pass to method
 :param object uid: a unique identifier (used for verification)
 :param slot readycb: the callback used when data is receieved
 :param slot errorcb: the callback used when there is an error

 The uid param is sent to your error and update callbacks as the
 first argument. It's there to verify the data you're returning

 After created it should be used by invoking:

 .. code-block:: python

 task = Request(...)
 QtCore.QThreadPool.globalInstance().start(task)

 """
 INSTANCES = []
 FINISHED = []
 def __init__(self, method, args, uid, readycb, errorcb=None):
 super(Request, self).__init__()
 self.setAutoDelete(True)
 self.cancelled = False

 self.method = method
 self.args = args
 self.uid = uid
 self.dataReady = readycb
 self.dataError = errorcb

 Request.INSTANCES.append(self)

 # release all of the finished tasks
 Request.FINISHED = []

 def run(self):
 """
 Method automatically called by Qt when the runnable is ready to run.
 This will run in a separate thread.
 """
 # this allows us to "cancel" queued tasks if needed, should be done
 # on shutdown to prevent the app from hanging
 if self.cancelled:
 self.cleanup()
 return

 # runs in a separate thread, for proper async signal/slot behavior
 # the object that emits the signals must be created in this thread.
 # Its not possible to run grabber.moveToThread(QThread.currentThread())
 # so to get this QObject to properly exhibit asynchronous
 # signal and slot behavior it needs to live in the thread that
 # we're running in, creating the object from within this thread
 # is an easy way to do that.
 grabber = Requester()
 grabber.Loaded.connect(self.dataReady, Qt.QueuedConnection)
 if self.dataError is not None:
 grabber.Error.connect(self.dataError, Qt.QueuedConnection)

 try:
 result = self.method(*self.args)
 if self.cancelled:
 # cleanup happens in 'finally' statement
 return
 grabber.Loaded.emit(self.uid, result)
 except Exception as error:
 if self.cancelled:
 # cleanup happens in 'finally' statement
 return
 grabber.Error.emit(self.uid, unicode(error))
 finally:
 # this will run even if one of the above return statements
 # is executed inside of the try/except statement see:
 # https://docs.python.org/2.7/tutorial/errors.html#defining-clean-up-actions
 self.cleanup(grabber)

 def cleanup(self, grabber=None):
 # remove references to any object or method for proper ref counting
 self.method = None
 self.args = None
 self.uid = None
 self.dataReady = None
 self.dataError = None

 if grabber is not None:
 grabber.deleteLater()

 # make sure this python obj gets cleaned up
 self.remove()

 def remove(self):
 try:
 Request.INSTANCES.remove(self)

 # when the next request is created, it will clean this one up
 # this will help us avoid this object being cleaned up
 # when it's still being used
 Request.FINISHED.append(self)
 except ValueError:
 # there might be a race condition on shutdown, when shutdown()
 # is called while the thread is still running and the instance
 # has already been removed from the list
 return

 @staticmethod
 def shutdown():
 for inst in Request.INSTANCES:
 inst.cancelled = True
 Request.INSTANCES = []
 Request.FINISHED = []


class Requester(QtCore.QObject):
 """
 A simple object designed to be used in a separate thread to allow
 for asynchronous data fetching
 """

 #
 # Signals
 #

 Error = QtCore.pyqtSignal(object, unicode)
 """
 Emitted if the fetch fails for any reason

 :param unicode uid: an id to identify this request
 :param unicode error: the error message
 """

 Loaded = QtCore.pyqtSignal(object, object)
 """
 Emitted whenever data comes back successfully

 :param unicode uid: an id to identify this request
 :param list data: the json list returned from the GET
 """

 NetworkConnectionError = QtCore.pyqtSignal(unicode)
 """
 Emitted when the task fails due to a network connection error

 :param unicode message: network connection error message
 """

 def __init__(self, parent=None):
 super(Requester, self).__init__(parent)


class ExampleObject(QtCore.QObject):
 def __init__(self, parent=None):
 super(ExampleObject, self).__init__(parent)
 self.uid = 0
 self.request = None

 def ready_callback(self, uid, result):
 if uid != self.uid:
 return
 print "Data ready from %s: %s" % (uid, result)

 def error_callback(self, uid, error):
 if uid != self.uid:
 return
 print "Data error from %s: %s" % (uid, error)

 def fetch(self):
 if self.request is not None:
 # cancel any pending requests
 self.request.cancelled = True
 self.request = None

 self.uid += 1
 self.request = async(slow_method, ["arg1", "arg2"], self.uid,
 self.ready_callback,
 self.error_callback)


def slow_method(arg1, arg2):
 print "Starting slow method"
 time.sleep(1)
 return arg1 + arg2


if __name__ == "__main__":
 import sys
 app = QtGui.QApplication(sys.argv)

 obj = ExampleObject()

 dialog = QtGui.QDialog()
 layout = QtGui.QVBoxLayout(dialog)
 button = QtGui.QPushButton("Generate", dialog)
 progress = QtGui.QProgressBar(dialog)
 progress.setRange(0, 0)
 layout.addWidget(button)
 layout.addWidget(progress)
 button.clicked.connect(obj.fetch)
 dialog.show()

 app.exec_()
 app.deleteLater() # avoids some QThread messages in the shell on exit
 # cancel all running tasks avoid QThread/QTimer error messages
 # on exit
 Request.shutdown()
</code></pre>

When exiting the application you'll want to make sure you cancel all of the tasks or the application will hang until every scheduled task has completed

entityMap|blocks|key|8lud2|text|基于其他答案中提到的Worker对象方法，我决定看看是否可以扩展解决方案以调用更多线程-在这种情况下，机器可以运行的最佳数量，并使用不确定的完成时间旋转多个Worker。要做到这一点，我仍然需要创建QThread的子类--但只需要分配一个线程号，并“重新实现”信号“finished”和“started”，以包含它们的线程号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fffbt|我已经把相当多的精力放在了主gui、线程和工作者之间的信号上。|afpfj|同样，其他人的回答也很痛苦地指出没有养育QThread，但我不认为这是一个真正的问题。但是，我的代码也会小心地销毁QThread对象。|5a76v|但是，我无法为worker对象设置父对象，因此无论是在线程函数完成还是图形用户界面被销毁时，似乎都希望向它们发送deleteLater()信号。我有我自己的代码挂起，因为我没有做到这一点。|2d64v|我认为另一个必要的增强是重新实现图形用户界面的closeEvent+(QWidget)，这样线程将被指示退出，然后图形用户界面将等待，直到所有线程都完成。当我使用这个问题的其他一些答案时，我得到了QThread销毁错误。|f5egi|也许它会对其他人有用。我确实发现这是一个很有用的练习。也许其他人会知道让线程声明其身份的更好方法。|53d91|And+the+worker+code+below|offset|length|style|CODE^0|0|0|0|0|0|0|0|P^^$0|$]|1|@$2|3|4|5|6|7|8|S|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|T|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|U|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|V|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|W|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|X|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|Y|9|@$O|Z|P|10|Q|R]]|A|@]|B|$]]]]

Based on the Worker objects methods mentioned in other answers, I decided to see if I could expand on the solution to invoke more threads - in this case the optimal number the machine can run and spin up multiple workers with indeterminate completion times.
To do this I still need to subclass QThread - but only to assign a thread number and to 'reimplement' the signals 'finished' and 'started' to include their thread number.

I've focused quite a bit on the signals between the main gui, the threads, and the workers.

Similarly, others answers have been a pains to point out not parenting the QThread but I don't think this is a real concern. However, my code also is careful to destroy the QThread objects.

However, I wasn't able to parent the worker objects so it seems desirable to send them the deleteLater() signal, either when the thread function is finished or the GUI is destroyed. I've had my own code hang for not doing this.

Another enhancement I felt was necessary was was reimplement the closeEvent of the GUI (QWidget) such that the threads would be instructed to quit and then the GUI would wait until all the threads were finished. When I played with some of the other answers to this question, I got QThread destroyed errors.

Perhaps it will be useful to others. I certainly found it a useful exercise. Perhaps others will know a better way for a thread to announce it identity.

<pre><code>#!/usr/bin/env python3
#coding:utf-8
# Author: --&lt;&gt;
# Purpose: To demonstrate creation of multiple threads and identify the receipt of thread results
# Created: 19/12/15

import sys


from PyQt4.QtCore import QThread, pyqtSlot, pyqtSignal
from PyQt4.QtGui import QApplication, QLabel, QWidget, QGridLayout

import sys
import worker

class Thread(QThread):
 #make new signals to be able to return an id for the thread
 startedx = pyqtSignal(int)
 finishedx = pyqtSignal(int)

 def __init__(self,i,parent=None):
 super().__init__(parent)
 self.idd = i

 self.started.connect(self.starttt)
 self.finished.connect(self.finisheddd)

 @pyqtSlot()
 def starttt(self):
 print('started signal from thread emitted')
 self.startedx.emit(self.idd) 

 @pyqtSlot()
 def finisheddd(self):
 print('finished signal from thread emitted')
 self.finishedx.emit(self.idd)

class Form(QWidget):

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

 self.initUI()

 self.worker={}
 self.threadx={}
 self.i=0
 i=0

 #Establish the maximum number of threads the machine can optimally handle
 #Generally relates to the number of processors

 self.threadtest = QThread(self)
 self.idealthreadcount = self.threadtest.idealThreadCount()

 print("This machine can handle {} threads optimally".format(self.idealthreadcount))

 while i &lt;self.idealthreadcount:
 self.setupThread(i)
 i+=1

 i=0
 while i&lt;self.idealthreadcount:
 self.startThread(i)
 i+=1

 print("Main Gui running in thread {}.".format(self.thread()))


 def setupThread(self,i):

 self.worker[i]= worker.Worker(i) # no parent!
 #print("Worker object runningt in thread {} prior to movetothread".format(self.worker[i].thread()) )
 self.threadx[i] = Thread(i,parent=self) # if parent isn't specified then need to be careful to destroy thread 
 self.threadx[i].setObjectName("python thread{}"+str(i))
 #print("Thread object runningt in thread {} prior to movetothread".format(self.threadx[i].thread()) )
 self.threadx[i].startedx.connect(self.threadStarted)
 self.threadx[i].finishedx.connect(self.threadFinished)

 self.worker[i].finished.connect(self.workerFinished)
 self.worker[i].intReady.connect(self.workerResultReady)

 #The next line is optional, you may want to start the threads again without having to create all the code again.
 self.worker[i].finished.connect(self.threadx[i].quit)

 self.threadx[i].started.connect(self.worker[i].procCounter)

 self.destroyed.connect(self.threadx[i].deleteLater)
 self.destroyed.connect(self.worker[i].deleteLater)

 #This is the key code that actually get the worker code onto another processor or thread.
 self.worker[i].moveToThread(self.threadx[i])

 def startThread(self,i):
 self.threadx[i].start()

 @pyqtSlot(int)
 def threadStarted(self,i):
 print('Thread {} started'.format(i))
 print("Thread priority is {}".format(self.threadx[i].priority())) 


 @pyqtSlot(int)
 def threadFinished(self,i):
 print('Thread {} finished'.format(i))




 @pyqtSlot(int)
 def threadTerminated(self,i):
 print("Thread {} terminated".format(i))

 @pyqtSlot(int,int)
 def workerResultReady(self,j,i):
 print('Worker {} result returned'.format(i))
 if i ==0:
 self.label1.setText("{}".format(j))
 if i ==1:
 self.label2.setText("{}".format(j))
 if i ==2:
 self.label3.setText("{}".format(j))
 if i ==3:
 self.label4.setText("{}".format(j)) 

 #print('Thread {} has started'.format(self.threadx[i].currentThreadId())) 

 @pyqtSlot(int)
 def workerFinished(self,i):
 print('Worker {} finished'.format(i))

 def initUI(self):
 self.label1 = QLabel("0")
 self.label2= QLabel("0")
 self.label3= QLabel("0")
 self.label4 = QLabel("0")
 grid = QGridLayout(self)
 self.setLayout(grid)
 grid.addWidget(self.label1,0,0)
 grid.addWidget(self.label2,0,1) 
 grid.addWidget(self.label3,0,2) 
 grid.addWidget(self.label4,0,3) #Layout parents the self.labels

 self.move(300, 150)
 self.setGeometry(0,0,300,300)
 #self.size(300,300)
 self.setWindowTitle('thread test')
 self.show()

 def closeEvent(self, event):
 print('Closing')

 #this tells the threads to stop running
 i=0
 while i &lt;self.idealthreadcount:
 self.threadx[i].quit()
 i+=1

 #this ensures window cannot be closed until the threads have finished.
 i=0
 while i &lt;self.idealthreadcount:
 self.threadx[i].wait() 
 i+=1 


 event.accept()


if __name__=='__main__':
 app = QApplication(sys.argv)
 form = Form()
 sys.exit(app.exec_())
</code></pre>

And the worker code below

<pre><code>#!/usr/bin/env python3
#coding:utf-8
# Author: --&lt;&gt;
# Purpose: Stack Overflow
# Created: 19/12/15

import sys
import unittest


from PyQt4.QtCore import QThread, QObject, pyqtSignal, pyqtSlot
import time
import random


class Worker(QObject):
 finished = pyqtSignal(int)
 intReady = pyqtSignal(int,int)

 def __init__(self, i=0):
 '''__init__ is called while the worker is still in the Gui thread. Do not put slow or CPU intensive code in the __init__ method'''

 super().__init__()
 self.idd = i



 @pyqtSlot()
 def procCounter(self): # This slot takes no params
 for j in range(1, 10):
 random_time = random.weibullvariate(1,2)
 time.sleep(random_time)
 self.intReady.emit(j,self.idd)
 print('Worker {0} in thread {1}'.format(self.idd, self.thread().idd))

 self.finished.emit(self.idd)


if __name__=='__main__':
 unittest.main()
</code></pre>

entityMap|blocks|key|2vko0|text|PySide2解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|46nib|与PyQt5不同的是，在PySide2中，QThread.started信号是在原始线程上接收/处理的，而不是在工作线程上接收/处理的！幸运的是，它仍然接收工作线程上的所有其他信号。|ecmqt|为了匹配PyQt5的行为，您必须自己创建启动信号。|bptek|这里有一个简单的解决方案：^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|K|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|L|9|@]|A|@]|B|$]]]]

<h1>PySide2 Solution:</h1>
Unlike in PyQt5, in PySide2 the QThread.started signal is received/handled on the original thread, not the worker thread! Luckily it still receives all other signals on the worker thread.
In order to match PyQt5's behavior, you have to create the started signal yourself.
Here is an easy solution:
<pre><code># Use this class instead of QThread
class QThread2(QThread):
 # Use this signal instead of &quot;started&quot;
 started2 = Signal()

 def __init__(self):
 QThread.__init__(self)
 self.started.connect(self.onStarted)

 def onStarted(self):
 self.started2.emit()
</code></pre>

I have a program which interfaces with a radio I am using via a gui I wrote in PyQt. Obviously one of the main functions of the radio is to transmit data, but to do this continuously, I have to loop the writes, which causes the gui to hang. Since I have never dealt with threading, I tried to get rid of these hangs using <code>QCoreApplication.processEvents().</code> The radio needs to sleep between transmissions, though, so the gui still hangs based on how long these sleeps last. 

Is there a simple way to fix this using QThread? I have looked for tutorials on how to implement multithreading with PyQt, but most of them deal with setting up servers and are much more advanced than I need them to be. I honestly don't even really need my thread to update anything while it is running, I just need to start it, have it transmit in the background, and stop it.

Background thread with QThread in PyQt

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

 我有一个程序，它通过我用PyQt编写的图形用户界面与我正在使用的收音机接口。显然，无线电的主要功能之一是传输数据，但要连续这样做，我必须循环写入，这会导致gui挂起。因为我从来没有处理过线程，所以我尝试使用QCoreApplication.processEvents().来摆脱这些挂起，不过无线电需要在两次传输之间休眠，所以gui仍然会根据这些休眠持续的时间而挂起。 有没有使用QThread解决

问在PyQt中使用QThread的后台线程
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在PyQt中使用QThread的后台线程EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在PyQt中使用QThread的后台线程
EN