你不能直接做你想做的事。后台线程正在运行它的run
函数,它只是永远循环,所以它不可能做任何其他事情。
当然,您可以在自己的线程上调用该类的方法,但这可能不是您想要的。
像 Qt、.NET 或 Cocoa 这样的框架可以提供runOnOtherThread
-type 方法的原因是每个线程都运行一个“事件循环”,所以他们真正做的只是发布一个事件。run
如果您将方法重写为事件循环,您可以自己执行此操作。例如:
import queue
import threading
class SomeClass(threading.Thread):
def __init__(self, q, loop_time = 1.0/60):
self.q = q
self.timeout = loop_time
super(SomeClass, self).__init__()
def onThread(self, function, *args, **kwargs):
self.q.put((function, args, kwargs))
def run(self):
while True:
try:
function, args, kwargs = self.q.get(timeout=self.timeout)
function(*args, **kwargs)
except queue.Empty:
self.idle()
def idle(self):
# put the code you would have put in the `run` loop here
def doSomething(self):
pass
def doSomethingElse(self):
pass
现在,您可以这样做:
someClass = SomeClass()
someClass.start()
someClass.onThread(someClass.doSomething)
someClass.onThread(someClass.doSomethingElse)
someClass.onThread(someClass.doSomething)
如果你想稍微简化调用接口,以类中更多的代码为代价,你可以像这样添加包装器方法:
def _doSomething(self):
# put the real code here
def doSomething(self):
self.onThread(self._doSomething)
但是,除非您的idle
方法有工作要做,否则您实际上只是在此处构建等效的单线程线程池,并且执行此操作的方法比从头构建要简单得多。例如,使用futures
PyPI 之外的模块(Python 3concurrent.futures
模块的反向移植):
import futures
class SomeClass(object):
def doSomething(self):
pass
def doSomethingElse(self):
pass
someClass = SomeClass()
with futures.ThreadPoolExecutor(1) as executor:
executor.submit(someClass.doSomething)
executor.submit(someClass.doSomethingElse)
executor.submit(someClass.doSomething)
或者,仅使用标准库:
from multiprocessing import dummy as multithreading
class SomeClass(object):
def doSomething(self):
pass
def doSomethingElse(self):
pass
someClass = SomeClass()
pool = multithreading.Pool(1)
pool.apply(someClass.doSomething)
pool.apply(someClass.doSomethingElse)
pool.apply(someClass.doSomething)
pool.close()
pool.join()
池还有其他一些优点,而执行者则更多。例如,如果方法返回值,并且您想启动两个函数,然后等待结果,然后使用前两个函数的结果启动第三个函数怎么办?简单的:
with futures.ThreadPoolExecutor(1) as executor:
f1 = executor.submit(someClass.doSomething)
f2 = executor.submit(someClass.doSomethingElse)
futures.wait((f1, f2))
f3 = executor.submit(someClass.doSomethingElser, f1.result(), f2.result())
result = f3.result()
即使您稍后切换到 4 个线程池,因此f1
并且f2
可能同时等待f2
甚至可能首先返回,您也可以保证在doSomethingElser
它们都完成后立即启动,而不是更早。
这里还有另一种可能。您真的需要代码在该线程中运行,还是只需要它来修改线程所依赖的变量?如果是后者,只需同步对变量的访问即可。例如:
class SomeClass(threading.Thread):
def __init__(self):
self.things_lock = threading.Lock()
self.things = []
while True:
with self.lock:
things = self.things[:]
for thing in things:
# pass
def doSomething(self):
with self.lock:
self.things.append(0)
someClass = SomeClass()
someClass.start()
someClass.doSomething()
在这里的主线程上没有什么神奇的。如果除了需要修改SomeClass
依赖的变量之外,您还想启动doSomething
主线程,以便您可以做比等待它完成更重要的事情,您可以创建一个短暂的额外线程,只是为了doSomething
:
someClass = SomeClass()
someClass.start()
somethingThread = threading.Thread(target=someClass.doSomething)
somethingThread.start()
doOtherImportantStuffWithSomethingIsHappening()
somethingThread.join()