如何在运行的Python线程上调用函数

Question

假设我有一个生成线程的类：

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()函数内部调用函数，但这不是我的目标。

Answer 1

你不能直接做你想做的事。后台线程正在运行其run函数，该函数只是永远循环，因此它不可能执行任何其他操作。

当然，您可以在自己的线程上调用类的方法，但这可能不是您想要的。

---

Qt、.NET或Cocoa等框架可以提供runOnOtherThread类型方法的原因是每个线程都运行一个“事件循环”，所以它们真正做的就是发布一个事件。如果将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方法有工作要做，否则您实际上只是在这里构建一个等效于单线程线程池的线程池，并且有比从头构建更简单的方法。例如，使用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)

或者，只要stdlib：

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()

Answer 2

查看concurrent.futures及其submit方法，当您将线程池限制为一个工作线程时，该方法可以满足您的需要。