简单线程池：
  1. #!/usr/bin/env python
  2. # Version = 3.5.2
  3. # __auth__ = '无名小妖'
  4. import queue
  5. import threading
  6. import time
  9. class ThreadPool:
  10.     """
  11.     简易线程池类，缺陷：1.线程无法重用
  12.                     2.初始线程最大化，可能导致浪费
  13.     """
  14.     def __init__(self, maxsize=5):
  15.         """
  16.         通过队列实现线程池
  17.         :param maxsize: 线程池最大值
  18.         """
  19.         self.maxsize = maxsize
  20.         self._q = queue.Queue(maxsize)
  21.         # 将线程类循环放入队列
  22.         for i in range(maxsize):
  23.             self._q.put(threading.Thread)
  25.     def get_thread(self):
  26.         """
  27.         从队列中取出线程类
  28.         :return: 线程类
  29.         """
  30.         return self._q.get()
  32.     def add_thread(self):
  33.         """
  34.         放入类
  35.         :return: none
  36.         """
  37.         self._q.put(threading.Thread)
  39. # 实例化线程池
  40. pool = ThreadPool()
  42. # 测试函数
  43. def task(a, p):
  44.     print(a)
  45.     time.sleep(1)
  46.     p.add_thread()
  48. for i in range(100):
  49.     t = pool.get_thread()
  50.     t_obj = t(target=task, args=(i, pool))
  51.     t_obj.start()


优化线程池：
  1. #!/usr/bin/env python
  2. # Version = 3.5.2
  3. # __auth__ = '无名小妖'
  4. import queue
  5. import threading
  6. import contextlib
  7. import time
  9. # 静态字段，线程停止标记
  10. StopEvent = object()
  13. class ThreadPool(object):
  15.     def __init__(self, max_num, max_task_num = None):
  16.         """
  18.         :param max_num: 线程池大小
  19.         :param max_task_num: 任务数量，默认无限
  20.         """
  21.         if max_task_num:
  22.             self.q = queue.Queue(max_task_num)
  23.         else:
  24.             self.q = queue.Queue()
  25.         self.max_num = max_num
  26.         self.cancel = False
  27.         self.terminal = False
  28.         self.generate_list = []  # 当前创建的线程
  29.         self.free_list = []  # 当前空闲的线程
  31.     def run(self, func, args, callback=None):
  32.         """
  33.         线程池执行一个任务
  34.         :param func: 任务函数
  35.         :param args: 任务函数所需参数
  36.         :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；
  37.                         2、任务函数返回值（默认为None，即：不执行回调函数）
  38.         :return: 如果线程池已经终止，则返回True否则None
  39.         """
  40.         if self.cancel:
  41.             return
  42.         # 判断  如果没有空闲线程 并且 已经创建的线程小于最大线程数，创建新线程
  43.         if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
  44.             self.generate_thread()
  45.         # 把任务放队列
  46.         w = (func, args, callback,)
  47.         self.q.put(w)
  49.     def generate_thread(self):
  50.         """
  51.         创建一个线程，并执行call方法
  52.         """
  53.         t = threading.Thread(target=self.call)
  54.         t.start()
  56.     def call(self):
  57.         """
  58.         循环去获取任务函数并执行任务函数
  59.         """
  60.         current_thread = threading.currentThread()
  61.         self.generate_list.append(current_thread)
  63.         event = self.q.get()  # 取任务
  64.         while event != StopEvent:  # 循环执行任务
  66.             func, arguments, callback = event
  67.             try:
  68.                 result = func(*arguments)  # 任务函数
  69.                 success = True
  70.             except Exception as e:
  71.                 success = False
  72.                 result = None
  74.             if callback is not None:
  75.                 try:
  76.                     callback(success, result)  # 回调函数
  77.                 except Exception as e:
  78.                     pass
  80.             # 执行完任务，将线程置为空闲
  81.             with self.worker_state(self.free_list, current_thread):
  82.                 if self.terminal:
  83.                     event = StopEvent
  84.                 else:
  85.                     event = self.q.get()
  86.         else:
  88.             self.generate_list.remove(current_thread)
  90.     def close(self):
  91.         """
  92.         执行完所有的任务后，所有线程停止
  93.         """
  94.         self.cancel = True
  95.         full_size = len(self.generate_list)
  96.         while full_size:
  97.             self.q.put(StopEvent)  # 将终止标识放入队列
  98.             full_size -= 1
  100.     def terminate(self):
  101.         """
  102.         无论是否还有任务，终止线程
  103.         """
  104.         self.terminal = True
  106.         while self.generate_list:
  107.             self.q.put(StopEvent)
  109.         self.q.queue.clear()
  111.     """ 经常使用到的with场景是（打开文件进行文件处理，
  112.         然后隐式地执行了文件句柄的关闭，同样适合socket之类的，这些类都提供了对with的支持）
  113.         contextlib是为了加强with语句，提供上下文机制的模块，它是通过Generator实现的。
  114.         contextlib中的contextmanager作为装饰器来提供一种针对函数级别的上下文管理机制 ."""
  115.     @contextlib.contextmanager
  116.     def worker_state(self, state_list, worker_thread):
  117.         """
  118.         用于记录线程中正在等待的线程数
  119.         """
  120.         state_list.append(worker_thread)
  121.         try:
  122.             yield
  123.         finally:
  124.             state_list.remove(worker_thread)
  126. # 实例化线程池
  127. pool = ThreadPool(3)
  129. def callback(status, result):
  130.     # status, execute action status
  131.     # result, execute action return value
  132.     if status == True:
  133.         print('Completed!')
  136. def action(i):
  137.     print(i)
  139. for i in range(30):
  140.     ret = pool.run(action, (i,), callback)
  142. time.sleep(5)
  143. print(len(pool.generate_list), len(pool.free_list))
  144. pool.close()
  145. # pool.terminate()