28

假设我有这个生成线程的类:

import threading
class SomeClass(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        while True:
            pass

    def doSomething(self):
        pass

    def doSomethingElse(self):
        pass

我想要

someClass = SomeClass()
someClass.start()
someClass.doSomething()
someClass.doSomethingElse()
someClass.doSomething()

我怎样才能做到这一点?我知道我可以在函数内部调用一个函数run(),但这不是我的目标。

4

2 回答 2

61

你不能直接做你想做的事。后台线程正在运行它的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方法有工作要做,否则您实际上只是在此处构建等效的单线程线程池,并且执行此操作的方法比从头构建要简单得多。例如,使用futuresPyPI 之外的模块(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()
于 2013-09-26T17:10:20.477 回答
1

查看concurrent.futures及其submit方法,当您将线程池限制为一个工作人员时,它可以满足您的需求。

于 2013-09-26T16:56:05.393 回答