Pool di threading simile al pool di elaborazione multipla?

Esiste una classe Pool per thread di lavoro , simile alla classe Pool del modulo multiprocessing ?

Mi piace ad esempio il modo semplice di parallelizzare una funzione della mappa

def long_running_func(p):
    c_func_no_gil(p)

p = multiprocessing.Pool(4)
xs = p.map(long_running_func, range(100))

tuttavia vorrei farlo senza il sovraccarico di creare nuovi processi.

Conosco il GIL. Tuttavia, nel mio caso d'uso, la funzione sarà una funzione C associata a IO per la quale il wrapper python rilascerà il GIL prima della chiamata effettiva alla funzione.

Devo scrivere il mio pool di threading?

Ho appena scoperto che in realtà non v'è un'interfaccia pool di thread-based nel multiprocessingmodulo, ma è nascosto un po 'e non adeguatamente documentata.

Può essere importato tramite

from multiprocessing.pool import ThreadPool

È implementato usando una classe Process fittizia che avvolge un thread Python. Questa classe di processo basata su thread può essere trovata in multiprocessing.dummycui è menzionata brevemente nei documenti . Questo modulo fittizio fornisce presumibilmente l'intera interfaccia multiprocessore basata su thread.

In Python 3 puoi usare concurrent.futures.ThreadPoolExecutor, cioè:

executor = ThreadPoolExecutor(max_workers=10)
a = executor.submit(my_function)

Vedi i documenti per maggiori informazioni ed esempi.

Sì, e sembra avere (più o meno) la stessa API.

import multiprocessing

def worker(lnk):
    ....    
def start_process():
    .....
....

if(PROCESS):
    pool = multiprocessing.Pool(processes=POOL_SIZE, initializer=start_process)
else:
    pool = multiprocessing.pool.ThreadPool(processes=POOL_SIZE, 
                                           initializer=start_process)

pool.map(worker, inputs)
....

Per qualcosa di molto semplice e leggero (leggermente modificato da qui ):

from Queue import Queue
from threading import Thread


class Worker(Thread):
    """Thread executing tasks from a given tasks queue"""
    def __init__(self, tasks):
        Thread.__init__(self)
        self.tasks = tasks
        self.daemon = True
        self.start()

    def run(self):
        while True:
            func, args, kargs = self.tasks.get()
            try:
                func(*args, **kargs)
            except Exception, e:
                print e
            finally:
                self.tasks.task_done()


class ThreadPool:
    """Pool of threads consuming tasks from a queue"""
    def __init__(self, num_threads):
        self.tasks = Queue(num_threads)
        for _ in range(num_threads):
            Worker(self.tasks)

    def add_task(self, func, *args, **kargs):
        """Add a task to the queue"""
        self.tasks.put((func, args, kargs))

    def wait_completion(self):
        """Wait for completion of all the tasks in the queue"""
        self.tasks.join()

if __name__ == '__main__':
    from random import randrange
    from time import sleep

    delays = [randrange(1, 10) for i in range(100)]

    def wait_delay(d):
        print 'sleeping for (%d)sec' % d
        sleep(d)

    pool = ThreadPool(20)

    for i, d in enumerate(delays):
        pool.add_task(wait_delay, d)

    pool.wait_completion()

Per supportare i callback al completamento dell'attività è sufficiente aggiungere il callback alla tupla dell'attività.

Ciao per usare il pool di thread in Python puoi usare questa libreria:

from multiprocessing.dummy import Pool as ThreadPool

e poi per l'uso, questa libreria fa così:

pool = ThreadPool(threads)
results = pool.map(service, tasks)
pool.close()
pool.join()
return results

I thread sono il numero di thread desiderati e le attività sono un elenco di attività che la maggior parte associa al servizio.

Ecco il risultato che alla fine ho usato. È una versione modificata delle classi di dgorissen sopra.

File: threadpool.py

from queue import Queue, Empty
import threading
from threading import Thread


class Worker(Thread):
    _TIMEOUT = 2
    """ Thread executing tasks from a given tasks queue. Thread is signalable, 
        to exit
    """
    def __init__(self, tasks, th_num):
        Thread.__init__(self)
        self.tasks = tasks
        self.daemon, self.th_num = True, th_num
        self.done = threading.Event()
        self.start()

    def run(self):       
        while not self.done.is_set():
            try:
                func, args, kwargs = self.tasks.get(block=True,
                                                   timeout=self._TIMEOUT)
                try:
                    func(*args, **kwargs)
                except Exception as e:
                    print(e)
                finally:
                    self.tasks.task_done()
            except Empty as e:
                pass
        return

    def signal_exit(self):
        """ Signal to thread to exit """
        self.done.set()


class ThreadPool:
    """Pool of threads consuming tasks from a queue"""
    def __init__(self, num_threads, tasks=[]):
        self.tasks = Queue(num_threads)
        self.workers = []
        self.done = False
        self._init_workers(num_threads)
        for task in tasks:
            self.tasks.put(task)

    def _init_workers(self, num_threads):
        for i in range(num_threads):
            self.workers.append(Worker(self.tasks, i))

    def add_task(self, func, *args, **kwargs):
        """Add a task to the queue"""
        self.tasks.put((func, args, kwargs))

    def _close_all_threads(self):
        """ Signal all threads to exit and lose the references to them """
        for workr in self.workers:
            workr.signal_exit()
        self.workers = []

    def wait_completion(self):
        """Wait for completion of all the tasks in the queue"""
        self.tasks.join()

    def __del__(self):
        self._close_all_threads()


def create_task(func, *args, **kwargs):
    return (func, args, kwargs)

Per usare la piscina

from random import randrange
from time import sleep

delays = [randrange(1, 10) for i in range(30)]

def wait_delay(d):
    print('sleeping for (%d)sec' % d)
    sleep(d)

pool = ThreadPool(20)
for i, d in enumerate(delays):
    pool.add_task(wait_delay, d)
pool.wait_completion()

Il sovraccarico della creazione di nuovi processi è minimo, soprattutto quando sono solo 4 di essi. Dubito che questo sia un punto caldo delle prestazioni della tua applicazione. Mantienilo semplice, ottimizza dove devi e dove puntano i risultati della profilazione.

Non esiste un pool basato su thread incorporato. Tuttavia, può essere molto veloce implementare una coda produttore / consumatore con la Queueclasse.

Da: https://docs.python.org/2/library/queue.html

from threading import Thread
from Queue import Queue
def worker():
    while True:
        item = q.get()
        do_work(item)
        q.task_done()

q = Queue()
for i in range(num_worker_threads):
     t = Thread(target=worker)
     t.daemon = True
     t.start()

for item in source():
    q.put(item)

q.join()       # block until all tasks are done

un altro modo può essere l'aggiunta del processo al pool di code del thread

import concurrent.futures
with concurrent.futures.ThreadPoolExecutor(max_workers=cpus) as executor:
    for i in range(0, len(list_of_files) - 1):
        a = executor.submit(loop_files2, i, list_of_files2, mt_list, temp_path, mt_dicto)