Conjunto de threads semelhante ao pool de multiprocessamento?

Existe uma classe Pool para threads de trabalho , semelhante à classe Pool do módulo de multiprocessamento ?

Eu gosto, por exemplo, da maneira fácil de paralelizar uma função de mapa

def long_running_func(p):
    c_func_no_gil(p)

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

no entanto, eu gostaria de fazê-lo sem a sobrecarga de criar novos processos.

Eu sei sobre o GIL. No entanto, no meu caso de usuário, a função será uma função C vinculada a IO para a qual o wrapper python liberará o GIL antes da chamada de função real.

Eu tenho que escrever minha própria piscina de threading?

Acabei de descobrir que realmente existe uma interface Pool baseada em encadeamento no multiprocessingmódulo, no entanto, ela está oculta e não está documentada corretamente.

Pode ser importado via

from multiprocessing.pool import ThreadPool

Ele é implementado usando uma classe fictícia Process que envolve um encadeamento python. Essa classe Process baseada em encadeamento pode ser encontrada na multiprocessing.dummyqual é mencionada brevemente nos documentos . Este módulo fictício supostamente fornece toda a interface de multiprocessamento baseada em threads.

No Python 3 você pode usar concurrent.futures.ThreadPoolExecutor, ou seja:

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

Veja os documentos para mais informações e exemplos.

Sim, e parece ter (mais ou menos) a mesma 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)
....

Para algo muito simples e leve (ligeiramente modificado a partir daqui ):

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

Para oferecer suporte a retornos de chamada na conclusão da tarefa, basta adicionar o retorno de chamada à tupla da tarefa.

Olá, para usar o pool de threads no Python, você pode usar esta biblioteca:

from multiprocessing.dummy import Pool as ThreadPool

e, para uso, esta biblioteca faz o seguinte:

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

Os threads são o número de threads que você deseja e as tarefas são uma lista das tarefas que mais são mapeadas para o serviço.

Aqui está o resultado que finalmente acabei usando. É uma versão modificada das classes por dgorissen acima.

Arquivo: 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)

Para usar a 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()

A sobrecarga de criação dos novos processos é mínima, especialmente quando são apenas quatro deles. Duvido que este seja um hot spot de desempenho do seu aplicativo. Mantenha-o simples, otimize para onde você precisa e para onde os resultados de criação de perfil apontam.

Não existe um pool baseado em encadeamento. No entanto, pode ser muito rápido implementar uma fila de produtores / consumidores com a Queueclasse.

De: 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

outra maneira pode ser adicionar o processo ao pool de filas

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)