Creazione di una discussione in python

Question

Ho una serie di "attività" che vorrei eseguire in thread separati. Le attività devono essere eseguite da moduli separati. Ciascuno contiene la logica di business per l'elaborazione dei propri compiti.

Data una tupla di attività, mi piacerebbe essere in grado di generare un nuovo thread per ciascun modulo come segue.

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) 

Nessun premio per indovinare Sto ancora pensando in C++. Come posso scrivere questo in modo Python usando gli 'enum' e 'switch' di Pythonic ed essere in grado di eseguire un modulo in una nuova discussione.

Ovviamente, i moduli avranno tutti una classe derivata da un ABC (classe base astratta) chiamato Plugin. Il metodo spawnWorker() verrà dichiarato nell'interfaccia Plugin e definito nelle classi implementate nei vari moduli.

Forse, c'è un modo migliore (cioè Pythonic) per fare tutto questo ?. Sarei interessato a sapere

[Edit]

Ho appena letto un bot di più e sembra Python non implementa threading nel vero senso (almeno, non nel senso che un programmatore C++ avrebbe pensato). In ogni caso questo non è uno spettacolo per me. Ognuna delle attività richiede molto tempo e non desidero rallentare l'avvio di un'attività finché non ne è stata completata un'altra, ecco perché utilizzo la filettatura. L'affinamento del tempo non mi infastidisce molto - purché siano tutti avviati praticamente contemporaneamente (o poco dopo l'altro) Python può quindi sovrapporsi tra le pedate quanto vuole - per me va bene.

Ho visto una risposta a una domanda simile qui su SO.

Un utente fornisce una semplice classe per la filettatura come segue:

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

Sto pensando di utilizzare questo per il mio ABC Plugin. La mia domanda allora è dove inserisco il codice in cui viene eseguito l'effettivo compito (cioè la logica aziendale). Presumo che questo vada nel metodo run() della classe Foo (ovvia domanda lo so, ma non voglio fare ipotesi).

È il mio pensiero sulla strada giusta o sbagliata (se difettoso -? Quello che ho perso)

Answer 1

Invece di caso, perché non utilizzare un polimorfismo adeguato? Ad esempio, ecco cosa si può fare con la tipizzazione anatra in Python:

, per esempio, alice.py:

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

, per esempio, bob.py:

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

Poi nel codice del client, dicono, 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() 

fatemi sapere se ho bisogno di chiarire.

Answer 2

Python può contenere funzioni come oggetti. Per superare la limitazione della mancanza di un interruttore mi permetto di suggerire quanto segue:

case_alice = lambda data : alice.spawnWorker(data) 

my_dict[alice] = case_alice 

formando un dizionario di tenere le "caso" dichiarazioni.

Colgo ancora di più:

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

sequenziale esecuzione

from foobar import alice, bob charles 

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

esecuzione parallela

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

Metti la tua logica in do_work funzioni corrispondenti mo Dules.