class WorkerPool(object):

def __init__(self, maxthreads=None): 

    """ init WorkerPool instance which may

            create up to `maxthreads` worker threads. 

        """

    self.maxthreads = maxthreads

    self._ready = {}

    self._alive = {}

def dispatch(self, func, *args, **kwargs): 

    """ return Reply object for the asynchronous dispatch 

            of the given func(*args, **kwargs) in a 

            separate worker thread. 

        """

    if self._shuttingdown: 

        raise IOError("WorkerPool is already shutting down") 

    try: 

        thread, _ = self._ready.popitem() 

    except KeyError: # pop from empty list

        if self.maxthreads and len(self._alive) >= self.maxthreads: 

            raise IOError("can't create more than %d threads." %

                          (self.maxthreads,))

        thread = self._newthread() 

    return thread.send((func, args, kwargs))

def join(self, timeout=None): 

    """ wait until all worker threads have terminated. """

    current = threading.currentThread()

    deadline = delta = None 

    if timeout is not None: 

        deadline = time.time() + timeout 

    for thread in self._alive.keys(): 

        if deadline: 

            delta = deadline - time.time() 

            if delta <= 0: 

                raise IOError("timeout while joining threads") 

        thread.join(timeout=delta) 

        if thread.isAlive(): 

            raise IOError("timeout while joining threads") 

def shutdown(self): 

    """ signal all worker threads to terminate. 

            call join() to wait until all threads termination. 

        """

    if not self._shuttingdown: 

        self._shuttingdown = True 

        for t in self._alive.keys(): 

            t.stop()