Engendrando un hilo en python

Question

Tengo una serie de 'tareas' que me gustaría ejecutar en hilos separados. Las tareas deben ser realizadas por módulos separados. Cada uno contiene la lógica comercial para procesar sus tareas.

Dando una tupla de tareas, me gustaría poder engendrar un nuevo hilo para cada módulo de la siguiente manera.

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) 

No hay premios para adivinar Todavía estoy pensando en C++. ¿Cómo puedo escribir esto de una manera Pythonic usando Pythonic 'enums' y 'switch'es, y ser capaz de ejecutar un módulo en un nuevo hilo.

Obviamente, los módulos tendrán una clase que se deriva de un ABC (clase base abstracta) llamado Plugin. El método spawnWorker() se declarará en la interfaz del complemento y se definirá en las clases implementadas en los diversos módulos.

Tal vez, hay una forma mejor (es decir, pitonica) de hacer todo esto ?. Yo estaría interesado en saber

[Editar]

He estado leyendo un bot más y parece que Python no implementa roscado en el verdadero sentido (al menos, no en el sentido de que un programador de C++ pensaría). En cualquier caso, eso no es un obstáculo para mí. Cada una de las tareas lleva bastante tiempo, y no quiero retrasar el inicio de una tarea hasta que otra se haya completado, por eso estoy usando el enhebrado. Cortar el tiempo no me molesta demasiado, siempre y cuando todos se inicien casi al mismo tiempo (o poco después) Python puede hacer un ciclo de tiempo entre las huellas tanto como quiera, está bien para mí.

He visto la respuesta a una pregunta similar aquí en SO.

un usuario proporciona una clase simple para el roscado de la siguiente manera:

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

estoy pensando en usar esto para mi ABC Plugin. Mi pregunta es, entonces, ¿dónde coloco el código donde se realiza la tarea real (es decir, la lógica de negocios). Supongo que esto va en el método run() de la clase Foo (pregunta obvia que sé, pero no quiero hacer ninguna suposición).

Es mi forma de pensar en el camino correcto o defectuoso (si es defectuoso - lo que me he perdido)

Answer 1

En lugar de la caja del interruptor, ¿por qué no utilizar un polimorfismo apropiado? Por ejemplo, aquí lo que se puede hacer con la tipificación de pato en Python:

en, digamos, alice.py:

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

en, digamos, bob.py:

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

Luego, en su código de cliente, decir, 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() 

Avísame si necesito aclarar.

Answer 2

Python puede contener funciones como objetos. Para superar la limitación de que carecen de un interruptor puedo sugerir lo siguiente:

case_alice = lambda data : alice.spawnWorker(data) 

my_dict[alice] = case_alice 

formando un diccionario para mantener sus estados de "caso".

Quiero aprovechar aún más:

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

Answer 3

ejecución secuencial

from foobar import alice, bob charles 

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

ejecución paralela

from threading import Thread 
from foobar import alice, bob charles 

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

Answer 4

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

Ponga su lógica en do_work funciones del correspondiente mes dules.