在python中产生一个线程

Question

我有一系列“任务”，我想在单独的线程中运行。这些任务将由单独的模块执行。每个都包含用于处理其任务的业务逻辑。

给定一组任务，我希望能够为每个模块生成一个新线程，如下所示。

from foobar import alice, bob charles
data = getWorkData()
# these are enums (which I just found Python doesn't support natively) :(
tasks = (alice, bob, charles)

for task in tasks
  # Ok, just found out Python doesn't have a switch - @#$%!
  # yet another thing I'll need help with then ...
  switch
    case alice:
      #spawn thread here - how ?
      alice.spawnWorker(data)

没有奖赏我还在用 C++ 思考。如何使用 Pythonic 'enums' 和 'switch'es 以 Pythonic 方式编写它，并能够在新线程中运行模块。

显然，这些模块都有一个派生自 ABC（抽象基类）的类，称为 Plugin。 spawnWorker() 方法将在 Plugin 接口上声明并在各个模块中实现的类中定义。

也许，有更好的（即 Pythonic）方式来完成这一切？我很想知道

[编辑]

我刚刚阅读了更多机器人，但似乎 Python 并没有实现真正意义上的线程（至少，不是 C++ 程序员所认为的意义上的）。在任何情况下，这对我来说都不是表演的终结者。每个任务都相当耗时，我不想在另一个任务完成之前等待启动一个任务，这就是我使用线程的原因。时间切片并没有给我带来太多困扰——只要它们几乎同时启动（或彼此紧随其后），Python 就可以根据需要在踏板之间进行时间切片——这对我来说很好。

我在 SO 上看到了类似问题的答案。

用户提供了一个简单的线程类，如下所示：

import threading
class Foo (threading.Thread):
    def __init__(self,x):
        self.__x = x
        threading.Thread.__init__(self)
    def run (self):
          print str(self.__x)

for x in xrange(20):
    Foo(x).start()

我正在考虑将它用于我的 ABC 插件。然后我的问题是我将代码放在哪里完成实际任务（即业务逻辑）。我假设这在 Foo 类的 run() 方法中（我知道一个明显的问题，但我不想做任何假设）。

我的想法是正确的还是有缺陷的（如果有缺陷 - 我错过了什么？）

Answer 1

为什么不使用适当的多态而不是 switch-case？例如，在这里你可以用 Python 中的鸭子类型做什么：

比如alice.py:

def do_stuff(data):
    print 'alice does stuff with %s' % data

比如bob.py:

def do_stuff(data):
    print 'bob does stuff with %s' % data

然后在您的客户端代码中，例如，main.py:

import threading
import alice, bob

def get_work_data():
    return 'data'

def main():
    tasks = [alice.do_stuff, bob.do_stuff]
    data = get_work_data()
    for task in tasks:
        t = threading.Thread(target=task, args=(data,))
        t.start()

如果我需要澄清，请告诉我。

Answer 2

import threading
from foobar import alice, bob, charles

data = get_work_data() # names_in_pep8 are more Pythonic than camelCased

for mod in [alice, bob, charles]:
    # mod is an object that represent a module
    worker = getattr(mod, 'do_work')
    # worker now is a reference to the function like alice.do_work
    t = threading.Thread(target=worker, args=[data])
    # uncomment following line if you don't want to block the program
    # until thread finishes on termination
    #t.daemon = True 
    t.start()

把你的逻辑放到对应模块的do_work函数中。

Answer 3

顺序执行：

from foobar import alice, bob, charles

for fct in (alice, bob, charles):
    fct()

并行执行：

from threading import Thread
from foobar import alice, bob, charles

for fct in (alice, bob, charles):
    Thread(target=fct).start()

Answer 4

Python 可以将函数保存为对象。为了克服缺少开关的限制，我可以提出以下建议：

case_alice = lambda data : alice.spawnWorker(data)

my_dict[alice] = case_alice

组成一个字典来保存你的“案例”陈述。

让我更进一步：

data = getWorkData()
case_alice = lambda d : alice.spawnWorker( d )
case_bob = lambda d : bob.spawnWorker( d )
case_charles = lambda d : charles.spawnWorker( d )

switch = { alice : case_alice, bob : case_bob, charles : case_charles }
spawn = lambda person : switch[ person ]( data )
[ spawn( item ) for item in (alice, bob, charles )]