Nhóm luồng tương tự như nhóm đa xử lý?

Có một lớp Pool cho các luồng công nhân , tương tự như lớp Pool của mô đun đa xử lý không?

Tôi thích ví dụ cách dễ dàng để song song hóa một chức năng bản đồ

def long_running_func(p):
    c_func_no_gil(p)

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

tuy nhiên tôi muốn làm điều đó mà không cần chi phí tạo ra các quy trình mới.

Tôi biết về GIL. Tuy nhiên, trong usecase của tôi, hàm sẽ là hàm C ràng buộc IO mà trình bao bọc python sẽ giải phóng GIL trước khi gọi hàm thực tế.

Tôi có phải viết nhóm luồng của riêng tôi?

Tôi chỉ phát hiện ra rằng thực sự có một giao diện Pool dựa trên luồng trong multiprocessingmô-đun, tuy nhiên nó bị ẩn đi đôi chút và không được ghi lại đúng cách.

Nó có thể được nhập qua

from multiprocessing.pool import ThreadPool

Nó được thực hiện bằng cách sử dụng một lớp Process giả bao bọc một chuỗi python. Lớp Process dựa trên luồng này có thể được tìm thấy trong multiprocessing.dummyđó được đề cập ngắn gọn trong các tài liệu . Mô-đun giả này được cho là cung cấp toàn bộ giao diện đa xử lý dựa trên các luồng.

Trong Python 3 bạn có thể sử dụng concurrent.futures.ThreadPoolExecutor, tức là:

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

Xem các tài liệu để biết thêm thông tin và ví dụ.

Có, và dường như có (ít nhiều) cùng một 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)
....

Đối với một cái gì đó rất đơn giản và nhẹ (sửa đổi một chút từ đây ):

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

Để hỗ trợ các cuộc gọi lại khi hoàn thành nhiệm vụ, bạn chỉ cần thêm cuộc gọi lại vào bộ tác vụ.

Xin chào để sử dụng nhóm luồng trong Python, bạn có thể sử dụng thư viện này:

from multiprocessing.dummy import Pool as ThreadPool

và sau đó để sử dụng, thư viện này làm như thế:

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

Các luồng là số lượng luồng mà bạn muốn và các tác vụ là một danh sách các tác vụ mà hầu hết ánh xạ tới dịch vụ.

Đây là kết quả cuối cùng tôi đã sử dụng. Đây là phiên bản sửa đổi của các lớp bởi dgorissen ở trên.

Tập tin: 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)

Sử dụng hồ bơi

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

Chi phí chung của việc tạo các quy trình mới là tối thiểu, đặc biệt là khi chỉ có 4 quy trình. Tôi nghi ngờ đây là một điểm nóng hiệu suất của ứng dụng của bạn. Giữ cho nó đơn giản, tối ưu hóa nơi bạn phải đến và nơi kết quả hồ sơ chỉ đến.

Không có xây dựng trong hồ bơi dựa trên chủ đề. Tuy nhiên, có thể rất nhanh để thực hiện hàng đợi nhà sản xuất / người tiêu dùng vớiQueue lớp.

Từ: https://docs.python.org/2/l 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

một cách khác có thể là thêm quá trình vào nhóm hàng đợi

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)