#!/usr/bin/env  python
# --*--coding:utf-8 --*--
import Queue
import threading

class ThreadPool(object):
#创建类
    def __init__(self, max_num=20):#进程函数，默认最大20个进程
        self.queue = Queue.Queue(max_num)#生成进程
        for i in xrange(max_num):#循环进程
            self.queue.put(threading.Thread)#上传进程

def get_thread(self):#下载进程函数
        return self.queue.get()

def add_thread(self):#生成进程函数
        self.queue.put(threading.Thread)

pool = ThreadPool(10)#执行类，并传默认进程数值

def func(arg, p):#打印进程
    print arg
    import time
    time.sleep(2)#间隔2秒
    p.add_thread()

for i in xrange(30):#循环进程
    thread = pool.get_thread()
    t = thread(target=func, args=(i, pool))#传值到func函数，并且执行
    t.start()

from Queue import Queue
import contextlib
import threading
 
WorkerStop = object()
 
 
class ThreadPool:
 
    workers = 0
 
    threadFactory = threading.Thread
    currentThread = staticmethod(threading.currentThread)
 
    def __init__(self, maxthreads=20, name=None):
 
        self.q = Queue(0)
        self.max = maxthreads
        self.name = name
        self.waiters = []
        self.working = []
 
    def start(self):
        while self.workers < min(self.max, self.q.qsize()+len(self.working)):
            self.startAWorker()
 
    def startAWorker(self):
        self.workers += 1
        name = "PoolThread-%s-%s" % (self.name or id(self), self.workers)
        newThread = self.threadFactory(target=self._worker, name=name)
        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.contextmanager
    def _workerState(self, stateList, workerThread):
        stateList.append(workerThread)
        try:
            yield
        finally:
            stateList.remove(workerThread)
 
    def _worker(self):
        ct = self.currentThread()
        o = self.q.get()
        while o is not WorkerStop:
            with self._workerState(self.working, ct):
                function, args, kwargs, onResult = o
                del o
                try:
                    result = function(*args, **kwargs)
                    success = True
                except:
                    success = False
                    if onResult is None:
                        pass
 
                    else:
                        pass
 
                del function, args, kwargs
 
                if onResult is not None:
                    try:
                        onResult(success, result)
                    except:
                        #context.call(ctx, log.err)
                        pass
 
                del onResult, result
 
            with self._workerState(self.waiters, ct):
                o = self.q.get()
 
    def stop(self):
        while self.workers:
            self.q.put(WorkerStop)
            self.workers -= 1
 
 
"""
def show(arg):
    import time
    time.sleep(1)
    print arg
 
 
pool = ThreadPool(20)
 
for i in range(500):
    pool.callInThread(show, i)
 
pool.start()
pool.stop()
"""