เธรดพูลคล้ายกับการประมวลผลหลายพูล?

มีคลาส Pool สำหรับเธรดผู้ปฏิบัติงานซึ่งคล้ายกับคลาส Poolของโมดูลมัลติโพรเซสเซอร์หรือไม่?

ฉันชอบตัวอย่างวิธีที่ง่ายที่สุดในการทำให้ขนานกับฟังก์ชันแผนที่

def long_running_func(p):
    c_func_no_gil(p)

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

อย่างไรก็ตามฉันต้องการทำโดยไม่มีค่าใช้จ่ายในการสร้างกระบวนการใหม่

ฉันรู้เกี่ยวกับ GIL อย่างไรก็ตามใน usecase ของฉันฟังก์ชั่นจะเป็นฟังก์ชั่น C แบบ IO-bound ซึ่งตัวห่องูหลามจะปล่อย GIL ก่อนการเรียกใช้ฟังก์ชันจริง

ฉันต้องเขียนเธรดพูลของตัวเองหรือไม่?

ฉันเพิ่งค้นพบว่ามีจริง เป็นอินเตอร์เฟซที่สระว่ายน้ำด้ายอยู่ในmultiprocessingโมดูล แต่มันถูกซ่อนอยู่บ้างและเอกสารไม่ถูกต้อง

มันสามารถนำเข้าผ่าน

from multiprocessing.pool import ThreadPool

มันถูกนำมาใช้โดยใช้กระบวนการจำลองชั้นห่อด้ายหลาม กระบวนการคลาด้ายตามนี้สามารถพบได้ในmultiprocessing.dummyซึ่งเป็นเวลาสั้น ๆ ที่กล่าวถึงในเอกสาร โมดูลตัวจำลองนี้ควรจัดหาอินเตอร์เฟสแบบหลายตัวประมวลผลทั้งหมดตามเธรด

ใน Python 3 คุณสามารถใช้concurrent.futures.ThreadPoolExecutorเช่น:

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

ดูเอกสารสำหรับข้อมูลเพิ่มเติมและตัวอย่าง

ใช่และดูเหมือนว่าจะมี 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)
....

สำหรับสิ่งที่ง่ายและมีน้ำหนักเบา (แก้ไขเล็กน้อยจากที่นี่ ):

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

เพื่อรองรับการโทรกลับเมื่องานเสร็จสมบูรณ์คุณสามารถเพิ่มการโทรกลับไปที่ทูเปิลภารกิจ

สวัสดีที่จะใช้เธรดพูลใน Python คุณสามารถใช้ไลบรารี่นี้:

from multiprocessing.dummy import Pool as ThreadPool

แล้วสำหรับการใช้งานห้องสมุดนี้ทำเช่นนั้น:

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

เธรดคือจำนวนเธรดที่คุณต้องการและงานคือรายการของงานที่แม็พกับบริการมากที่สุด

นี่คือผลลัพธ์ที่ฉันใช้ในที่สุด มันเป็นรุ่นที่แก้ไขของคลาสโดย dgorissen ด้านบน

ไฟล์: 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)

หากต้องการใช้สระ

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

ค่าใช้จ่ายในการสร้างกระบวนการใหม่นั้นน้อยมากโดยเฉพาะเมื่อเป็นเพียงแค่ 4 กระบวนการเท่านั้น ฉันสงสัยว่านี่คือแอปพลิเคชั่นยอดนิยมของคุณ ทำให้ง่ายเพิ่มประสิทธิภาพในที่ที่คุณต้องไปและที่ซึ่งผลการทำโปรไฟล์ชี้ไปที่

ไม่มีบิวด์พูลตามเธรด อย่างไรก็ตามสามารถทำได้อย่างรวดเร็วในการใช้คิวผู้ผลิต / ผู้บริโภคกับQueueคลาส

จาก: 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

วิธีอื่นสามารถเพิ่มกระบวนการในเธรดพูลเธรด

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)