pool = ThreadPool(poolsize)
requests = makeRequests(some_callable,list_of_args,callback)
[pool.putRequest(req) for req in requests]
pool.wait()

import sys
import threading
import Queue
import traceback

# exceptions
class NoResultsPending(Exception):
? ? """All work requests have been processed."""
? ? pass

class NoWorkersAvailable(Exception):
? ? """No worker threads available to process remaining requests."""
? ? pass


# internal module helper functions
def _handle_thread_exception(request, exc_info):
? ? """Default exception handler callback function.

? ? This just prints the exception info via ``traceback.print_exception``.

? ? """
? ? traceback.print_exception(*exc_info)


# utility functions
def makeRequests(callable_, args_list, callback=None, ?#用來(lái)創(chuàng)建多個(gè)任務(wù)請(qǐng)求 callback是回調(diào)函數(shù)處理結(jié)果，exc_callback是用來(lái)處理發(fā)生的異常
? ? ? ? exc_callback=_handle_thread_exception):
? ? """Create several work requests for same callable with different arguments.

? ? Convenience function for creating several work requests for the same
? ? callable where each invocation of the callable receives different values
? ? for its arguments.

? ? ``args_list`` contains the parameters for each invocation of callable.
? ? Each item in ``args_list`` should be either a 2-item tuple of the list of
? ? positional arguments and a dictionary of keyword arguments or a single,
? ? non-tuple argument.

? ? See docstring for ``WorkRequest`` for info on ``callback`` and
? ? ``exc_callback``.

? ? """
? ? requests = []
? ? for item in args_list:
? ? ? ? if isinstance(item, tuple):
? ? ? ? ? ? requests.append(
? ? ? ? ? ? ? ? WorkRequest(callable_, item[0], item[1], callback=callback,
? ? ? ? ? ? ? ? ? ? exc_callback=exc_callback)
? ? ? ? ? ? )
? ? ? ? else:
? ? ? ? ? ? requests.append(
? ? ? ? ? ? ? ? WorkRequest(callable_, [item], None, callback=callback,
? ? ? ? ? ? ? ? ? ? exc_callback=exc_callback)
? ? ? ? ? ? )
? ? return requests


# classes
class WorkerThread(threading.Thread): ? ? #工作線程
? ? """Background thread connected to the requests/results queues.

? ? A worker thread sits in the background and picks up work requests from
? ? one queue and puts the results in another until it is dismissed.

? ? """

? ? def __init__(self, requests_queue, results_queue, poll_timeout=5, **kwds):
? ? ? ? """Set up thread in daemonic mode and start it immediatedly.

? ? ? ? ``requests_queue`` and ``results_queue`` are instances of
? ? ? ? ``Queue.Queue`` passed by the ``ThreadPool`` class when it creates a new
? ? ? ? worker thread.

? ? ? ? """
? ? ? ? threading.Thread.__init__(self, **kwds)
? ? ? ? self.setDaemon(1)
? ? ? ? self._requests_queue = requests_queue ? ? #任務(wù)隊(duì)列
? ? ? ? self._results_queue = results_queue ? ? ? #結(jié)果隊(duì)列
? ? ? ? self._poll_timeout = poll_timeout
? ? ? ? self._dismissed = threading.Event()
? ? ? ? self.start()

? ? def run(self):
? ? ? ? """Repeatedly process the job queue until told to exit."""
? ? ? ? while True:
? ? ? ? ? ? if self._dismissed.isSet(): ?#如果標(biāo)識(shí)位設(shè)為T(mén)rue，則表示線程非阻塞
? ? ? ? ? ? ? ? # we are dismissed, break out of loop
? ? ? ? ? ? ? ? break
? ? ? ? ? ? # get next work request. If we don't get a new request from the
? ? ? ? ? ? # queue after self._poll_timout seconds, we jump to the start of
? ? ? ? ? ? # the while loop again, to give the thread a chance to exit.
? ? ? ? ? ? try:
? ? ? ? ? ? ? ? request = self._requests_queue.get(True, self._poll_timeout)#獲取待處理任務(wù)，block設(shè)為T(mén)rue，標(biāo)識(shí)線程同步 ，并設(shè)置超時(shí)時(shí)間
? ? ? ? ? ? except Queue.Empty:
? ? ? ? ? ? ? ? continue
? ? ? ? ? ? else:
? ? ? ? ? ? ? ? if self._dismissed.isSet():再次判斷，因?yàn)樵谌∪蝿?wù)期間，線程有可能被掛起
? ? ? ? ? ? ? ? ? ? # we are dismissed, put back request in queue and exit loop
? ? ? ? ? ? ? ? ? ? self._requests_queue.put(request) #添加任務(wù)到任務(wù)隊(duì)列
? ? ? ? ? ? ? ? ? ? break
? ? ? ? ? ? ? ? try:
? ? ? ? ? ? ? ? ? ? result = request.callable(*request.args, **request.kwds)
? ? ? ? ? ? ? ? ? ? self._results_queue.put((request, result))
? ? ? ? ? ? ? ? except:
? ? ? ? ? ? ? ? ? ? request.exception = True
? ? ? ? ? ? ? ? ? ? self._results_queue.put((request, sys.exc_info()))

? ? def dismiss(self):
? ? ? ? """Sets a flag to tell the thread to exit when done with current job."""
? ? ? ? self._dismissed.set()


class WorkRequest: ? ? ?#創(chuàng)建單個(gè)任務(wù)請(qǐng)求
? ? """A request to execute a callable for putting in the request queue later.

? ? See the module function ``makeRequests`` for the common case
? ? where you want to build several ``WorkRequest`` objects for the same
? ? callable but with different arguments for each call.

? ? """

? ? def __init__(self, callable_, args=None, kwds=None, requestID=None,
? ? ? ? ? ? callback=None, exc_callback=_handle_thread_exception):
? ? ? ? """Create a work request for a callable and attach callbacks.

? ? ? ? A work request consists of the a callable to be executed by a
? ? ? ? worker thread, a list of positional arguments, a dictionary
? ? ? ? of keyword arguments.

? ? ? ? A ``callback`` function can be specified, that is called when the
? ? ? ? results of the request are picked up from the result queue. It must
? ? ? ? accept two anonymous arguments, the ``WorkRequest`` object and the
? ? ? ? results of the callable, in that order. If you want to pass additional
? ? ? ? information to the callback, just stick it on the request object.

? ? ? ? You can also give custom callback for when an exception occurs with
? ? ? ? the ``exc_callback`` keyword parameter. It should also accept two
? ? ? ? anonymous arguments, the ``WorkRequest`` and a tuple with the exception
? ? ? ? details as returned by ``sys.exc_info()``. The default implementation
? ? ? ? of this callback just prints the exception info via
? ? ? ? ``traceback.print_exception``. If you want no exception handler
? ? ? ? callback, just pass in ``None``.

? ? ? ? ``requestID``, if given, must be hashable since it is used by
? ? ? ? ``ThreadPool`` object to store the results of that work request in a
? ? ? ? dictionary. It defaults to the return value of ``id(self)``.

? ? ? ? """
? ? ? ? if requestID is None:
? ? ? ? ? ? self.requestID = id(self) #id返回對(duì)象的內(nèi)存地址
? ? ? ? else:
? ? ? ? ? ? try:
? ? ? ? ? ? ? ? self.requestID = hash(requestID) #哈希處理
? ? ? ? ? ? except TypeError:
? ? ? ? ? ? ? ? raise TypeError("requestID must be hashable.")
? ? ? ? self.exception = False
? ? ? ? self.callback = callback
? ? ? ? self.exc_callback = exc_callback
? ? ? ? self.callable = callable_
? ? ? ? self.args = args or []
? ? ? ? self.kwds = kwds or {}

? ? def __str__(self):
? ? ? ? return "<WorkRequest id=%s args=%r kwargs=%r exception=%s>" % \
? ? ? ? ? ? (self.requestID, self.args, self.kwds, self.exception)

class ThreadPool: ?#線程池管理器
? ? """A thread pool, distributing work requests and collecting results.

? ? See the module docstring for more information.

? ? """

? ? def __init__(self, num_workers, q_size=0, resq_size=0, poll_timeout=5):
? ? ? ? """Set up the thread pool and start num_workers worker threads.

? ? ? ? ``num_workers`` is the number of worker threads to start initially.

? ? ? ? If ``q_size > 0`` the size of the work *request queue* is limited and
? ? ? ? the thread pool blocks when the queue is full and it tries to put
? ? ? ? more work requests in it (see ``putRequest`` method), unless you also
? ? ? ? use a positive ``timeout`` value for ``putRequest``.

? ? ? ? If ``resq_size > 0`` the size of the *results queue* is limited and the
? ? ? ? worker threads will block when the queue is full and they try to put
? ? ? ? new results in it.

? ? ? ? .. warning:
? ? ? ? ? ? If you set both ``q_size`` and ``resq_size`` to ``!= 0`` there is
? ? ? ? ? ? the possibilty of a deadlock, when the results queue is not pulled
? ? ? ? ? ? regularly and too many jobs are put in the work requests queue.
? ? ? ? ? ? To prevent this, always set ``timeout > 0`` when calling
? ? ? ? ? ? ``ThreadPool.putRequest()`` and catch ``Queue.Full`` exceptions.

? ? ? ? """
? ? ? ? self._requests_queue = Queue.Queue(q_size) ?#任務(wù)隊(duì)列
? ? ? ? self._results_queue = Queue.Queue(resq_size) #結(jié)果隊(duì)列
? ? ? ? self.workers = [] ?#工作線程
? ? ? ? self.dismissedWorkers = [] #睡眠線程
? ? ? ? self.workRequests = {} ?#一個(gè)字典 鍵是id 值是request
? ? ? ? self.createWorkers(num_workers, poll_timeout)

? ? def createWorkers(self, num_workers, poll_timeout=5):
? ? ? ? """Add num_workers worker threads to the pool.

? ? ? ? ``poll_timout`` sets the interval in seconds (int or float) for how
? ? ? ? ofte threads should check whether they are dismissed, while waiting for
? ? ? ? requests.

? ? ? ? """
? ? ? ? for i in range(num_workers):
? ? ? ? ? ? self.workers.append(WorkerThread(self._requests_queue,
? ? ? ? ? ? ? ? self._results_queue, poll_timeout=poll_timeout))

? ? def dismissWorkers(self, num_workers, do_join=False):
? ? ? ? """Tell num_workers worker threads to quit after their current task."""
? ? ? ? dismiss_list = []
? ? ? ? for i in range(min(num_workers, len(self.workers))):
? ? ? ? ? ? worker = self.workers.pop()
? ? ? ? ? ? worker.dismiss()
? ? ? ? ? ? dismiss_list.append(worker)

? ? ? ? if do_join:
? ? ? ? ? ? for worker in dismiss_list:
? ? ? ? ? ? ? ? worker.join()
? ? ? ? else:
? ? ? ? ? ? self.dismissedWorkers.extend(dismiss_list)

? ? def joinAllDismissedWorkers(self):
? ? ? ? """Perform Thread.join() on all worker threads that have been dismissed.
? ? ? ? """
? ? ? ? for worker in self.dismissedWorkers:
? ? ? ? ? ? worker.join()
? ? ? ? self.dismissedWorkers = []

? ? def putRequest(self, request, block=True, timeout=None):
? ? ? ? """Put work request into work queue and save its id for later."""
? ? ? ? assert isinstance(request, WorkRequest)
? ? ? ? # don't reuse old work requests
? ? ? ? assert not getattr(request, 'exception', None)
? ? ? ? self._requests_queue.put(request, block, timeout)
? ? ? ? self.workRequests[request.requestID] = request ?#確立一對(duì)一對(duì)應(yīng)關(guān)系 一個(gè)id對(duì)應(yīng)一個(gè)request

? ? def poll(self, block=False):#處理任務(wù),
? ? ? ? """Process any new results in the queue."""
? ? ? ? while True:
? ? ? ? ? ? # still results pending?
? ? ? ? ? ? if not self.workRequests: #沒(méi)有任務(wù)
? ? ? ? ? ? ? ? raise NoResultsPending
? ? ? ? ? ? # are there still workers to process remaining requests?
? ? ? ? ? ? elif block and not self.workers:#無(wú)工作線程
? ? ? ? ? ? ? ? raise NoWorkersAvailable
? ? ? ? ? ? try:
? ? ? ? ? ? ? ? # get back next results
? ? ? ? ? ? ? ? request, result = self._results_queue.get(block=block)
? ? ? ? ? ? ? ? # has an exception occured?
? ? ? ? ? ? ? ? if request.exception and request.exc_callback:
? ? ? ? ? ? ? ? ? ? request.exc_callback(request, result)
? ? ? ? ? ? ? ? # hand results to callback, if any
? ? ? ? ? ? ? ? if request.callback and not \
? ? ? ? ? ? ? ? ? ? ? ?(request.exception and request.exc_callback):
? ? ? ? ? ? ? ? ? ? request.callback(request, result)
? ? ? ? ? ? ? ? del self.workRequests[request.requestID]
? ? ? ? ? ? except Queue.Empty:
? ? ? ? ? ? ? ? break

? ? def wait(self):
? ? ? ? """Wait for results, blocking until all have arrived."""
? ? ? ? while 1:
? ? ? ? ? ? try:
? ? ? ? ? ? ? ? self.poll(True)
? ? ? ? ? ? except NoResultsPending:
? ? ? ? ? ? ? ? break

import os
import threading
import time
from threading import Thread
from concurrent.futures import ThreadPoolExecutor


threadPool = ThreadPoolExecutor(max_workers=5,thread_name_prefix="test_")

def test(v1,v2):
    print(threading.current_thread().name,v1,v2)
    time.sleep(2)

if __name__=='__main__':

    for i in range(0,10):
        threadPool.submit(test,i,i+1)
    threadPool.shutdown(wait=True)