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): 
    pass 
  def createWorkers(self, num_workers, poll_timeout=5): 
    pass 
  def dismissWorkers(self, num_workers, do_join=False): 
    pass 
  def joinAllDismissedWorkers(self): 
    pass 
  def putRequest(self, request, block=True, timeout=None): 
    pass 
  def poll(self, block=False): 
    pass 
  def wait(self): 
    pass 

task_pool=threadpool.ThreadPool(num_works) 
  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)#任務隊列，通過threadpool.makeReuests(args)創(chuàng)建的任務都會放到此隊列中 
    self._results_queue = Queue.Queue(resq_size)#字典，任務對應的任務執(zhí)行結(jié)果</span> 
    self.workers = []#工作線程list，通過self.createWorkers()函數(shù)內(nèi)創(chuàng)建的工作線程會放到此工作線程list中 
    self.dismissedWorkers = []#被設置線程事件并且沒有被join的工作線程 
    self.workRequests = {}#字典，記錄任務被分配到哪個工作線程中</span> 
    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)) 

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#任務隊列 
    self._results_queue = results_queue#任務結(jié)果隊列 
    self._poll_timeout = poll_timeout#run函數(shù)中從任務隊列中g(shù)et任務時的超時時間，如果超時則繼續(xù)while(true)； 
    self._dismissed = threading.Event()#線程事件，如果set線程事件則run會執(zhí)行break,直接退出工作線程； 
    self.start() 
 
  def run(self): 
    """Repeatedly process the job queue until told to exit.""" 
    while True: 
      if self._dismissed.isSet():#如果設置了self._dismissed則退出工作線程 
 
        # 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) 
      except Queue.Empty:#嘗從任務 隊列self._requests_queue 中g(shù)et任務，如果隊列為空，則continue 
        continue 
      else: 
        if self._dismissed.isSet():#檢測此工作線程事件是否被set,如果被設置，意味著要結(jié)束此工作線程，那么就需要將取到的任務返回到任務隊列中，并且退出線程 
          # we are dismissed, put back request in queue and exit loop 
          self._requests_queue.put(request) 
          break 
        try:<span style="color:#如果線程事件沒有被設置，那么執(zhí)行任務處理函數(shù)request.callable，并將返回的result，壓入到任務結(jié)果隊列中 
          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()))#如果任務處理函數(shù)出現(xiàn)異常，則將異常壓入到隊列中 
 
  def dismiss(self):</span> 
    """Sets a flag to tell the thread to exit when done with current job. 
    """ 
    self._dismissed.set() 

# utility functions 
def makeRequests(callable_, args_list, callback=None, 
    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 

class WorkRequest: 
  """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) 
    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) 

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 

try: 
  request = self._requests_queue.get(True, self._poll_timeout) 
except Queue.Empty:#嘗從任務 隊列self._requests_queue 中g(shù)et任務，如果隊列為空，則continue 
  continue 

def run(self): 
    """Repeatedly process the job queue until told to exit.""" 
    while True: 
      if self._dismissed.isSet():#如果設置了self._dismissed則退出工作線程 
 
        # 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) 
      except Queue.Empty:#嘗從任務 隊列self._requests_queue 中g(shù)et任務，如果隊列為空，則continue 
        continue 
      else: 
        if self._dismissed.isSet():#檢測此工作線程事件是否被set,如果被設置，意味著要結(jié)束此工作線程，那么就需要將取到的任務返回到任務隊列中，并且退出線程 
          # we are dismissed, put back request in queue and exit loop 
          self._requests_queue.put(request) 
          break 
        try:#如果線程事件沒有被設置，那么執(zhí)行任務處理函數(shù)request.callable，并將返回的result，壓入到任務結(jié)果隊列中 
          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()))#如果任務處理函數(shù)出現(xiàn)異常，則將異常壓入到隊列中 

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

def poll(self, block=False): 
  """Process any new results in the queue.""" 
  while True: 
    # still results pending? 
    if not self.workRequests: 
      raise NoResultsPending 
    # are there still workers to process remaining requests? 
    elif block and not self.workers: 
      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 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 = []