5、双向队列(deque)一个线程安全的双向队列class deque(object):    """    deque([iterable[, maxlen]]) --> deque object        Build an ordered collection with optimized access from its endpoints.    """    def append(self, *args, **kwargs): # real signature unknown        """ Add an element to the right side of the deque. """        pass    def appendleft(self, *args, **kwargs): # real signature unknown        """ Add an element to the left side of the deque. """        pass    def clear(self, *args, **kwargs): # real signature unknown        """ Remove all elements from the deque. """        pass    def count(self, value): # real signature unknown; restored from __doc__        """ D.count(value) -> integer -- return number of occurrences of value """        return 0    def extend(self, *args, **kwargs): # real signature unknown        """ Extend the right side of the deque with elements from the iterable """        pass    def extendleft(self, *args, **kwargs): # real signature unknown        """ Extend the left side of the deque with elements from the iterable """        pass    def pop(self, *args, **kwargs): # real signature unknown        """ Remove and return the rightmost element. """        pass    def popleft(self, *args, **kwargs): # real signature unknown        """ Remove and return the leftmost element. """        pass    def remove(self, value): # real signature unknown; restored from __doc__        """ D.remove(value) -- remove first occurrence of value. """        pass    def reverse(self): # real signature unknown; restored from __doc__        """ D.reverse() -- reverse *IN PLACE* """        pass    def rotate(self, *args, **kwargs): # real signature unknown        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """        pass    def __copy__(self, *args, **kwargs): # real signature unknown        """ Return a shallow copy of a deque. """        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__('name') <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __iadd__(self, y): # real signature unknown; restored from __doc__        """ x.__iadd__(y) <==> x+=y """        pass    def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__        """        deque([iterable[, maxlen]]) --> deque object                Build an ordered collection with optimized access from its endpoints.        # (copied from class doc)        """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x
    
      a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __reversed__(self): # real signature unknown; restored from __doc__        """ D.__reversed__() -- return a reverse iterator over the deque """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ D.__sizeof__() -- size of D in memory, in bytes """        pass    maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    """maximum size of a deque or None if unbounded"""    __hash__ = Nonedeque
    

既然有双向队列，也有单项队列（先进先出 FIFO ）class Queue:    """Create a queue object with a given maximum size.    If maxsize is <= 0, the queue size is infinite.    """    def __init__(self, maxsize=0):        self.maxsize = maxsize        self._init(maxsize)        self.mutex = _threading.Lock()        self.not_empty = _threading.Condition(self.mutex)        self.not_full = _threading.Condition(self.mutex)        self.all_tasks_done = _threading.Condition(self.mutex)        self.unfinished_tasks = 0    def task_done(self):                self.all_tasks_done.acquire()        try:            unfinished = self.unfinished_tasks - 1            if unfinished <= 0:                if unfinished < 0:                    raise ValueError('task_done() called too many times')                self.all_tasks_done.notify_all()            self.unfinished_tasks = unfinished        finally:            self.all_tasks_done.release()    def join(self):               self.all_tasks_done.acquire()        try:            while self.unfinished_tasks:                self.all_tasks_done.wait()        finally:            self.all_tasks_done.release()    def qsize(self):        """Return the approximate size of the queue (not reliable!)."""        self.mutex.acquire()        n = self._qsize()        self.mutex.release()        return n    def empty(self):        """Return True if the queue is empty, False otherwise (not reliable!)."""        self.mutex.acquire()        n = not self._qsize()        self.mutex.release()        return n    def full(self):        """Return True if the queue is full, False otherwise (not reliable!)."""        self.mutex.acquire()        n = 0 < self.maxsize == self._qsize()        self.mutex.release()        return n    def put(self, item, block=True, timeout=None):               self.not_full.acquire()        try:            if self.maxsize > 0:                if not block:                    if self._qsize() == self.maxsize:                        raise Full                elif timeout is None:                    while self._qsize() == self.maxsize:                        self.not_full.wait()                elif timeout < 0:                    raise ValueError("'timeout' must be a non-negative number")                else:                    endtime = _time() + timeout                    while self._qsize() == self.maxsize:                        remaining = endtime - _time()                        if remaining <= 0.0:                            raise Full                        self.not_full.wait(remaining)            self._put(item)            self.unfinished_tasks += 1            self.not_empty.notify()        finally:            self.not_full.release()    def put_nowait(self, item):        """Put an item into the queue without blocking.        Only enqueue the item if a free slot is immediately available.        Otherwise raise the Full exception.        """        return self.put(item, False)    def get(self, block=True, timeout=None):                self.not_empty.acquire()        try:            if not block:                if not self._qsize():                    raise Empty            elif timeout is None:                while not self._qsize():                    self.not_empty.wait()            elif timeout < 0:                raise ValueError("'timeout' must be a non-negative number")            else:                endtime = _time() + timeout                while not self._qsize():                    remaining = endtime - _time()                    if remaining <= 0.0:                        raise Empty                    self.not_empty.wait(remaining)            item = self._get()            self.not_full.notify()            return item        finally:            self.not_empty.release()    def get_nowait(self):        """Remove and return an item from the queue without blocking.        Only get an item if one is immediately available. Otherwise        raise the Empty exception.        """        return self.get(False)        def _init(self, maxsize):        self.queue = deque()    def _qsize(self, len=len):        return len(self.queue)    # Put a new item in the queue    def _put(self, item):        self.queue.append(item)    # Get an item from the queue    def _get(self):        return self.queue.popleft()Queue.Queue