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 回答