线程池要点：
1、通过判断等待的任务数量和线程池中的最大值，取最小值来判断开启多少线程来工作
比如：
任务数是3，进程池最大20  ，那么咱们只需要开启3个线程就行了。
任务数是500，进程池是20，那么咱们只开20个线程就可以了。
取最小值2、实现线程池正在运行，有一个查看的功能，查看一下现在线程里面活跃的线程是多少等待的是多少？线程总共是多少，等待中多少，正在运行中多少
作用：
方便查看当前线程池状态
能获取到这个之后就可以当线程一直处于空闲状态查看状态用：上下文管理来做，非常nice的一点3、关闭线程

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luo_t'
import Queue
import threading
import time'''
这个简单的例子的想法是通过：
1、利用Queue特性，在Queue里创建多个线程对象
2、那我执行代码的时候，去queue里去拿线程！
如果线程池里有可用的，直接拿。
如果线程池里没有可用，那就等。
3、线程执行完毕，归还给线程池
'''class ThreadPool(object): #创建线程池类def __init__(self,max_thread=20):#构造方法，设置最大的线程数为20self.queue = Queue.Queue(max_thread) #创建一个队列for i in xrange(max_thread):#循环把线程对象加入到队列中
            self.queue.put(threading.Thread)#把线程的类名放进去，执行完这个Queuedef get_thread(self):#定义方法从队列里获取线程return self.queue.get()def add_thread(self):#定义方法在队列里添加线程
        self.queue.put(threading.Thread)pool = ThreadPool(10)def func(arg,p):print argtime.sleep(2)p.add_thread() #当前线程执行完了，我在队列里加一个线程！for i in xrange(300):thread = pool.get_thread() #线程池10个线程，每一次循环拿走一个！默认queue.get()，如果队列里没有数据就会等待。t = thread(target=func,args=(i,pool))t.start()'''
self.queue.put(threading.Thread) 添加的是类不是对象，在内存中如果相同的类只占一份内存空间
并且如果这里存储的是对象的话每次都的新增都得在内存中开辟一段内存空间还有如果是对象的话：下面的这个语句就不能这么调用了！
for i in xrange(300):thread = pool.get_thread()t = thread(target=func,args=(i,pool))t.start()通过查看源码可以知道，在thread的构造函数中：self.__args = args  self.__target = target  都是私有字段那么调用就应该这么写for i in xrange(300):ret = pool.get_thread()ret._Thread__target = funcret._Thread__args = (i,pool)ret.start()
'''

simple_pool.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luo_t'import Queue
obj = object() #object也是一个类，我创建了一个对象obj

q = Queue.Queue()
for i in range(10):print id(obj)#看萝卜号
    q.put(obj)
'''
这个队列里有10个萝卜(萝卜=obj),但是这10个萝卜只是个投影。
我们在for循环的时候put到队列里，obj有变化吗？是否有新开辟空间？显然没有
'''

knowledge_point_1.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luo_t'
import contextlib
import threading
import time
import randomdoing = []
def number(l2):while True:print len(l2)time.sleep(1)t = threading.Thread(target=number,args=(doing,))  #开启一个线程，每一秒打印列表，当前工作中的线程数量
t.start()#添加管理上下文的装饰器
@contextlib.contextmanager
def show(li,iterm):li.append(iterm)yield'''yield冻结这次操作，就出去了，with就会捕捉到，然后就会执行with下的代码块，当with下的代码块执行完毕后就会回来继续执行yield下面没有执行的代码块！然后就执行完毕了如果with代码块中的非常耗时，那么doing的长度是不是一直是1，说明他没执行完呢？我们就可以获取到正在执行的数量，当他with执行完毕后执行yield的后续的代码块。把他移除后就为0了！'''li.remove(iterm)def task(arg):with show(doing,1):#通过with管理上下文进行切换print len(doing)time.sleep(10) #等待10秒这里可以使用random模块来操作~for i in range(20): #开启20个线程执行temp = threading.Thread(target=task,args=(i,))temp.start()'''
作用：我们要记录正在工作的的列表
比如正在工作的线程我把加入到doing这个列表中，如果工作完成的把它从doing列表中移除。
通过这个机制，就可以获取现在正在执行的线程都有多少
'''

knowledge_point_2.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
__author__ = 'luo_t'
from Queue import Queue
import contextlib
import threadingWorkerStop = object()class ThreadPool:workers = 0threadFactory = threading.ThreadcurrentThread = staticmethod(threading.currentThread)def __init__(self, maxthreads=20, name=None):self.q = Queue(0) #这里创建一个队列，如果是0的话表示不限制，现在这个队列里放的是任务self.max = maxthreads #定义最大线程数self.name = nameself.waiters = []#这两个是用来计数的self.working = []#这两个是用来技术的def start(self):#self.max 最大线程数#q.qisze()，任务个数needSize = self.q.qsize()while self.workers < min(self.max, needSize):#min(10,20)取最小值#wokers默认为0  【workers = 0】'''举例来说：while self.workers < min(self.max, needSize):这个循环，比如最大线程为20，咱们的任务个数为10，取最小值为10每次循环开1个线程，并且workers自增1，那么循环10次后，开了10个线程了workers = 10 ,那么workers就不小于10了就不开线程了，我线程开到最大了，你们这10个线程去消耗这10个任务去吧并且这里不阻塞，创建完线程就去执行了！每一个线程都去执行_worker方法去了'''self.startAWorker()def startAWorker(self):self.workers += 1newThread = self.threadFactory(target=self._worker, name='shuaige') #创建一个线程并去执行_worker方法
        newThread.start()def callInThread(self, func, *args, **kw):self.callInThreadWithCallback(None, func, *args, **kw)def callInThreadWithCallback(self, onResult, func, *args, **kw):o = (func, args, kw, onResult)self.q.put(o)@contextlib.contextmanagerdef _workerState(self, stateList, workerThread):stateList.append(workerThread)try:yieldfinally:stateList.remove(workerThread)def _worker(self):ct = self.currentThread()o = self.q.get() #去队列里取任务,如果有任务就O就会有值，每个任务是个元组，有方法，有参数while o is not WorkerStop:with self._workerState(self.working, ct):  #上下文切换function, args, kwargs, onResult = odel otry:result = function(*args, **kwargs)success = Trueexcept:success = Falseif onResult is None:passelse:passdel function, args, kwargsif onResult is not None:try:onResult(success, result)except:#context.call(ctx, log.err)passdel onResult, resultwith self._workerState(self.waiters, ct): #当线程工作完闲暇的时候，在去取任务执行o = self.q.get()def stop(self): #定义关闭线程方法while self.workers: #循环workers值self.q.put(WorkerStop) #在队列中增加一个信号~self.workers -= 1 #workers值-1 直到所有线程关闭def show(arg):import timetime.sleep(1)print argpool = ThreadPool(10)#创建500个任务，队列里添加了500个任务
#每个任务都是一个元组（方法名，动态参数，动态参数，默认为NoNe）
for i in range(100):pool.callInThread(show, i)pool.start()  #队列添加完成之后，开启线程让线程一个一个去队列里去拿

pool.stop() #当上面的任务都执行完之后，线程中都在等待着在队列里去数据呢！
'''
我们要关闭所有的线程，执行stop方法，首先workers这个值是当前的线程数量，我们给线程发送一个信号“WorkerStop”
在线程的工作里：        while o is not WorkerStop:   如果线程获取到这个值就不执行了，然后这个线程while循环就停止了，等待
python的垃圾回收机制，回收。然后在self.workers -= 1 ，那么所有的线程收到这个信号之后就会停止！！！
over~
'''