threading

Module threading |
[hide private]
[frames] | no frames]

# Source Code for Module threading

      1  """Thread module emulating a subset of Java's threading model."""
      2
      3  import sys as _sys
      4
      5  try:
      6      import thread
      7  except ImportError:
      8      del _sys.modules[__name__]
      9      raise
     10
     11  import warnings
     12
     13  from functools import wraps
     14  from time import time as _time, sleep as _sleep
     15  from traceback import format_exc as _format_exc
     16  from collections import deque
     17
     18  # Note regarding PEP 8 compliant aliases
     19  #  This threading model was originally inspired by Java, and inherited
     20  # the convention of camelCase function and method names from that
     21  # language. While those names are not in any imminent danger of being
     22  # deprecated, starting with Python 2.6, the module now provides a
     23  # PEP 8 compliant alias for any such method name.
     24  # Using the new PEP 8 compliant names also facilitates substitution
     25  # with the multiprocessing module, which doesn't provide the old
     26  # Java inspired names.
     27
     28
     29  # Rename some stuff so "from threading import *" is safe
     30  __all__ = ['activeCount', 'active_count', 'Condition', 'currentThread',
     31             'current_thread', 'enumerate', 'Event',
     32             'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
     33             'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
     34
     35  _start_new_thread = thread.start_new_thread
     36  _allocate_lock = thread.allocate_lock
     37  _get_ident = thread.get_ident
     38  ThreadError = thread.error
     39  del thread
     40
     41
     42  # sys.exc_clear is used to work around the fact that except blocks
     43  # don't fully clear the exception until 3.0.
     44  warnings.filterwarnings('ignore', category=DeprecationWarning,
     45                          module='threading', message='sys.exc_clear')
     46
     47  # Debug support (adapted from ihooks.py).
     48  # All the major classes here derive from _Verbose.  We force that to
     49  # be a new-style class so that all the major classes here are new-style.
     50  # This helps debugging (type(instance) is more revealing for instances
     51  # of new-style classes).
     52
     53  _VERBOSE = False
     54
     55  if __debug__:
     56
     57 -    class _Verbose(object):
     58
     59 -        def __init__(self, verbose=None):
     60              if verbose is None:
     61                  verbose = _VERBOSE
     62              self.__verbose = verbose
     63
     64 -        def _note(self, format, *args):
     65              if self.__verbose:
     66                  format = format % args
     67                  format = "%s: %s\n" % (
     68                      current_thread().name, format)
     69                  _sys.stderr.write(format)
     70
     71  else:
     72      # Disable this when using "python -O"
     73 -    class _Verbose(object):
     74 -        def __init__(self, verbose=None):
     75              pass
     76 -        def _note(self, *args):
     77              pass
     78
     79  # Support for profile and trace hooks
     80
     81  _profile_hook = None
     82  _trace_hook = None
     83
     84 -def setprofile(func):
     85      global _profile_hook
     86      _profile_hook = func
     87
     88 -def settrace(func):
     89      global _trace_hook
     90      _trace_hook = func
     91
     92  # Synchronization classes
     93
     94  Lock = _allocate_lock
     95
     96 -def RLock(*args, **kwargs):
     97      return _RLock(*args, **kwargs)
     98
     99 -class _RLock(_Verbose):
    100
    101 -    def __init__(self, verbose=None):
    102          _Verbose.__init__(self, verbose)
    103          self.__block = _allocate_lock()
    104          self.__owner = None
    105          self.__count = 0
    106
    107 -    def __repr__(self):
    108          owner = self.__owner
    109          try:
    110              owner = _active[owner].name
    111          except KeyError:
    112              pass
    113          return "<%s owner=%r count=%d>" % (
    114                  self.__class__.__name__, owner, self.__count)
    115
    116 -    def acquire(self, blocking=1):
    117          me = _get_ident()
    118          if self.__owner == me:
    119              self.__count = self.__count + 1
    120              if __debug__:
    121                  self._note("%s.acquire(%s): recursive success", self, blocking)
    122              return 1
    123          rc = self.__block.acquire(blocking)
    124          if rc:
    125              self.__owner = me
    126              self.__count = 1
    127              if __debug__:
    128                  self._note("%s.acquire(%s): initial success", self, blocking)
    129          else:
    130              if __debug__:
    131                  self._note("%s.acquire(%s): failure", self, blocking)
    132          return rc
    133
    134      __enter__ = acquire
    135
    136 -    def release(self):
    137          if self.__owner != _get_ident():
    138              raise RuntimeError("cannot release un-acquired lock")
    139          self.__count = count = self.__count - 1
    140          if not count:
    141              self.__owner = None
    142              self.__block.release()
    143              if __debug__:
    144                  self._note("%s.release(): final release", self)
    145          else:
    146              if __debug__:
    147                  self._note("%s.release(): non-final release", self)
    148
    149 -    def __exit__(self, t, v, tb):
    150          self.release()
    151
    152      # Internal methods used by condition variables
    153
    154 -    def _acquire_restore(self, count_owner):
    155          count, owner = count_owner
    156          self.__block.acquire()
    157          self.__count = count
    158          self.__owner = owner
    159          if __debug__:
    160              self._note("%s._acquire_restore()", self)
    161
    162 -    def _release_save(self):
    163          if __debug__:
    164              self._note("%s._release_save()", self)
    165          count = self.__count
    166          self.__count = 0
    167          owner = self.__owner
    168          self.__owner = None
    169          self.__block.release()
    170          return (count, owner)
    171
    172 -    def _is_owned(self):
    173          return self.__owner == _get_ident()
    174
    175
    176 -def Condition(*args, **kwargs):
    177      return _Condition(*args, **kwargs)
    178
    179 -class _Condition(_Verbose):
    180
    181 -    def __init__(self, lock=None, verbose=None):
    182          _Verbose.__init__(self, verbose)
    183          if lock is None:
    184              lock = RLock()
    185          self.__lock = lock
    186          # Export the lock's acquire() and release() methods
    187          self.acquire = lock.acquire
    188          self.release = lock.release
    189          # If the lock defines _release_save() and/or _acquire_restore(),
    190          # these override the default implementations (which just call
    191          # release() and acquire() on the lock).  Ditto for _is_owned().
    192          try:
    193              self._release_save = lock._release_save
    194          except AttributeError:
    195              pass
    196          try:
    197              self._acquire_restore = lock._acquire_restore
    198          except AttributeError:
    199              pass
    200          try:
    201              self._is_owned = lock._is_owned
    202          except AttributeError:
    203              pass
    204          self.__waiters = []
    205
    206 -    def __enter__(self):
    207          return self.__lock.__enter__()
    208
    209 -    def __exit__(self, *args):
    210          return self.__lock.__exit__(*args)
    211
    212 -    def __repr__(self):
    213          return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters))
    214
    215 -    def _release_save(self):
    216          self.__lock.release()           # No state to save
    217
    218 -    def _acquire_restore(self, x):
    219          self.__lock.acquire()           # Ignore saved state
    220
    221 -    def _is_owned(self):
    222          # Return True if lock is owned by current_thread.
    223          # This method is called only if __lock doesn't have _is_owned().
    224          if self.__lock.acquire(0):
    225              self.__lock.release()
    226              return False
    227          else:
    228              return True
    229
    230 -    def wait(self, timeout=None):
    231          if not self._is_owned():
    232              raise RuntimeError("cannot wait on un-acquired lock")
    233          waiter = _allocate_lock()
    234          waiter.acquire()
    235          self.__waiters.append(waiter)
    236          saved_state = self._release_save()
    237          try:    # restore state no matter what (e.g., KeyboardInterrupt)
    238              if timeout is None:
    239                  waiter.acquire()
    240                  if __debug__:
    241                      self._note("%s.wait(): got it", self)
    242              else:
    243                  # Balancing act:  We can't afford a pure busy loop, so we
    244                  # have to sleep; but if we sleep the whole timeout time,
    245                  # we'll be unresponsive.  The scheme here sleeps very
    246                  # little at first, longer as time goes on, but never longer
    247                  # than 20 times per second (or the timeout time remaining).
    248                  endtime = _time() + timeout
    249                  delay = 0.0005 # 500 us -> initial delay of 1 ms
    250                  while True:
    251                      gotit = waiter.acquire(0)
    252                      if gotit:
    253                          break
    254                      remaining = endtime - _time()
    255                      if remaining <= 0:
    256                          break
    257                      delay = min(delay * 2, remaining, .05)
    258                      _sleep(delay)
    259                  if not gotit:
    260                      if __debug__:
    261                          self._note("%s.wait(%s): timed out", self, timeout)
    262                      try:
    263                          self.__waiters.remove(waiter)
    264                      except ValueError:
    265                          pass
    266                  else:
    267                      if __debug__:
    268                          self._note("%s.wait(%s): got it", self, timeout)
    269          finally:
    270              self._acquire_restore(saved_state)
    271
    272 -    def notify(self, n=1):
    273          if not self._is_owned():
    274              raise RuntimeError("cannot notify on un-acquired lock")
    275          __waiters = self.__waiters
    276          waiters = __waiters[:n]
    277          if not waiters:
    278              if __debug__:
    279                  self._note("%s.notify(): no waiters", self)
    280              return
    281          self._note("%s.notify(): notifying %d waiter%s", self, n,
    282                     n!=1 and "s" or "")
    283          for waiter in waiters:
    284              waiter.release()
    285              try:
    286                  __waiters.remove(waiter)
    287              except ValueError:
    288                  pass
    289
    290 -    def notifyAll(self):
    291          self.notify(len(self.__waiters))
    292
    293      notify_all = notifyAll
    294
    295
    296 -def Semaphore(*args, **kwargs):
    297      return _Semaphore(*args, **kwargs)
    298
    299 -class _Semaphore(_Verbose):
    300
    301      # After Tim Peters' semaphore class, but not quite the same (no maximum)
    302
    303 -    def __init__(self, value=1, verbose=None):
    304          if value < 0:
    305              raise ValueError("semaphore initial value must be >= 0")
    306          _Verbose.__init__(self, verbose)
    307          self.__cond = Condition(Lock())
    308          self.__value = value
    309
    310 -    def acquire(self, blocking=1):
    311          rc = False
    312          self.__cond.acquire()
    313          while self.__value == 0:
    314              if not blocking:
    315                  break
    316              if __debug__:
    317                  self._note("%s.acquire(%s): blocked waiting, value=%s",
    318                             self, blocking, self.__value)
    319              self.__cond.wait()
    320          else:
    321              self.__value = self.__value - 1
    322              if __debug__:
    323                  self._note("%s.acquire: success, value=%s",
    324                             self, self.__value)
    325              rc = True
    326          self.__cond.release()
    327          return rc
    328
    329      __enter__ = acquire
    330
    331 -    def release(self):
    332          self.__cond.acquire()
    333          self.__value = self.__value + 1
    334          if __debug__:
    335              self._note("%s.release: success, value=%s",
    336                         self, self.__value)
    337          self.__cond.notify()
    338          self.__cond.release()
    339
    340 -    def __exit__(self, t, v, tb):
    341          self.release()
    342
    343
    344 -def BoundedSemaphore(*args, **kwargs):
    345      return _BoundedSemaphore(*args, **kwargs)
    346
    347 -class _BoundedSemaphore(_Semaphore):
    348      """Semaphore that checks that # releases is <= # acquires"""
    349 -    def __init__(self, value=1, verbose=None):
    350          _Semaphore.__init__(self, value, verbose)
    351          self._initial_value = value
    352
    353 -    def release(self):
    354          if self._Semaphore__value >= self._initial_value:
    355              raise ValueError, "Semaphore released too many times"
    356          return _Semaphore.release(self)
    357
    358
    359 -def Event(*args, **kwargs):
    360      return _Event(*args, **kwargs)
    361
    362 -class _Event(_Verbose):
    363
    364      # After Tim Peters' event class (without is_posted())
    365
    366 -    def __init__(self, verbose=None):
    367          _Verbose.__init__(self, verbose)
    368          self.__cond = Condition(Lock())
    369          self.__flag = False
    370
    371 -    def isSet(self):
    372          return self.__flag
    373
    374      is_set = isSet
    375
    376 -    def set(self):
    377          self.__cond.acquire()
    378          try:
    379              self.__flag = True
    380              self.__cond.notify_all()
    381          finally:
    382              self.__cond.release()
    383
    384 -    def clear(self):
    385          self.__cond.acquire()
    386          try:
    387              self.__flag = False
    388          finally:
    389              self.__cond.release()
    390
    391 -    def wait(self, timeout=None):
    392          self.__cond.acquire()
    393          try:
    394              if not self.__flag:
    395                  self.__cond.wait(timeout)
    396          finally:
    397              self.__cond.release()
    398
    399  # Helper to generate new thread names
    400  _counter = 0
    401 -def _newname(template="Thread-%d"):
    402      global _counter
    403      _counter = _counter + 1
    404      return template % _counter
    405
    406  # Active thread administration
    407  _active_limbo_lock = _allocate_lock()
    408  _active = {}    # maps thread id to Thread object
    409  _limbo = {}
    410
    411
    412  # Main class for threads
    413
    414 -class Thread(_Verbose):
    415
    416      __initialized = False
    417      # Need to store a reference to sys.exc_info for printing
    418      # out exceptions when a thread tries to use a global var. during interp.
    419      # shutdown and thus raises an exception about trying to perform some
    420      # operation on/with a NoneType
    421      __exc_info = _sys.exc_info
    422      # Keep sys.exc_clear too to clear the exception just before
    423      # allowing .join() to return.
    424      __exc_clear = _sys.exc_clear
    425
    426 -    def __init__(self, group=None, target=None, name=None,
    427                   args=(), kwargs=None, verbose=None):
    428          assert group is None, "group argument must be None for now"
    429          _Verbose.__init__(self, verbose)
    430          if kwargs is None:
    431              kwargs = {}
    432          self.__target = target
    433          self.__name = str(name or _newname())
    434          self.__args = args
    435          self.__kwargs = kwargs
    436          self.__daemonic = self._set_daemon()
    437          self.__ident = None
    438          self.__started = Event()
    439          self.__stopped = False
    440          self.__block = Condition(Lock())
    441          self.__initialized = True
    442          # sys.stderr is not stored in the class like
    443          # sys.exc_info since it can be changed between instances
    444          self.__stderr = _sys.stderr
    445
    446 -    def _set_daemon(self):
    447          # Overridden in _MainThread and _DummyThread
    448          return current_thread().daemon
    449
    450 -    def __repr__(self):
    451          assert self.__initialized, "Thread.__init__() was not called"
    452          status = "initial"
    453          if self.__started.is_set():
    454              status = "started"
    455          if self.__stopped:
    456              status = "stopped"
    457          if self.__daemonic:
    458              status += " daemon"
    459          if self.__ident is not None:
    460              status += " %s" % self.__ident
    461          return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status)
    462
    463 -    def start(self):
    464          if not self.__initialized:
    465              raise RuntimeError("thread.__init__() not called")
    466          if self.__started.is_set():
    467              raise RuntimeError("thread already started")
    468          if __debug__:
    469              self._note("%s.start(): starting thread", self)
    470          _active_limbo_lock.acquire()
    471          _limbo[self] = self
    472          _active_limbo_lock.release()
    473          try:
    474              _start_new_thread(self.__bootstrap, ())
    475          except Exception:
    476              with _active_limbo_lock:
    477                  del _limbo[self]
    478              raise
    479          self.__started.wait()
    480
    481 -    def run(self):
    482          try:
    483              if self.__target:
    484                  self.__target(*self.__args, **self.__kwargs)
    485          finally:
    486              # Avoid a refcycle if the thread is running a function with
    487              # an argument that has a member that points to the thread.
    488              del self.__target, self.__args, self.__kwargs
    489
    490 -    def __bootstrap(self):
    491          # Wrapper around the real bootstrap code that ignores
    492          # exceptions during interpreter cleanup.  Those typically
    493          # happen when a daemon thread wakes up at an unfortunate
    494          # moment, finds the world around it destroyed, and raises some
    495          # random exception *** while trying to report the exception in
    496          # __bootstrap_inner() below ***.  Those random exceptions
    497          # don't help anybody, and they confuse users, so we suppress
    498          # them.  We suppress them only when it appears that the world
    499          # indeed has already been destroyed, so that exceptions in
    500          # __bootstrap_inner() during normal business hours are properly
    501          # reported.  Also, we only suppress them for daemonic threads;
    502          # if a non-daemonic encounters this, something else is wrong.
    503          try:
    504              self.__bootstrap_inner()
    505          except:
    506              if self.__daemonic and _sys is None:
    507                  return
    508              raise
    509
    510 -    def _set_ident(self):
    511          self.__ident = _get_ident()
    512
    513 -    def __bootstrap_inner(self):
    514          try:
    515              self._set_ident()
    516              self.__started.set()
    517              _active_limbo_lock.acquire()
    518              _active[self.__ident] = self
    519              del _limbo[self]
    520              _active_limbo_lock.release()
    521              if __debug__:
    522                  self._note("%s.__bootstrap(): thread started", self)
    523
    524              if _trace_hook:
    525                  self._note("%s.__bootstrap(): registering trace hook", self)
    526                  _sys.settrace(_trace_hook)
    527              if _profile_hook:
    528                  self._note("%s.__bootstrap(): registering profile hook", self)
    529                  _sys.setprofile(_profile_hook)
    530
    531              try:
    532                  self.run()
    533              except SystemExit:
    534                  if __debug__:
    535                      self._note("%s.__bootstrap(): raised SystemExit", self)
    536              except:
    537                  if __debug__:
    538                      self._note("%s.__bootstrap(): unhandled exception", self)
    539                  # If sys.stderr is no more (most likely from interpreter
    540                  # shutdown) use self.__stderr.  Otherwise still use sys (as in
    541                  # _sys) in case sys.stderr was redefined since the creation of
    542                  # self.
    543                  if _sys:
    544                      _sys.stderr.write("Exception in thread %s:\n%s\n" %
    545                                        (self.name, _format_exc()))
    546                  else:
    547                      # Do the best job possible w/o a huge amt. of code to
    548                      # approximate a traceback (code ideas from
    549                      # Lib/traceback.py)
    550                      exc_type, exc_value, exc_tb = self.__exc_info()
    551                      try:
    552                          print>>self.__stderr, (
    553                              "Exception in thread " + self.name +
    554                              " (most likely raised during interpreter shutdown):")
    555                          print>>self.__stderr, (
    556                              "Traceback (most recent call last):")
    557                          while exc_tb:
    558                              print>>self.__stderr, (
    559                                  '  File "%s", line %s, in %s' %
    560                                  (exc_tb.tb_frame.f_code.co_filename,
    561                                      exc_tb.tb_lineno,
    562                                      exc_tb.tb_frame.f_code.co_name))
    563                              exc_tb = exc_tb.tb_next
    564                          print>>self.__stderr, ("%s: %s" % (exc_type, exc_value))
    565                      # Make sure that exc_tb gets deleted since it is a memory
    566                      # hog; deleting everything else is just for thoroughness
    567                      finally:
    568                          del exc_type, exc_value, exc_tb
    569              else:
    570                  if __debug__:
    571                      self._note("%s.__bootstrap(): normal return", self)
    572              finally:
    573                  # Prevent a race in
    574                  # test_threading.test_no_refcycle_through_target when
    575                  # the exception keeps the target alive past when we
    576                  # assert that it's dead.
    577                  self.__exc_clear()
    578          finally:
    579              with _active_limbo_lock:
    580                  self.__stop()
    581                  try:
    582                      # We don't call self.__delete() because it also
    583                      # grabs _active_limbo_lock.
    584                      del _active[_get_ident()]
    585                  except:
    586                      pass
    587
    588 -    def __stop(self):
    589          self.__block.acquire()
    590          self.__stopped = True
    591          self.__block.notify_all()
    592          self.__block.release()
    593
    594 -    def __delete(self):
    595          "Remove current thread from the dict of currently running threads."
    596
    597          # Notes about running with dummy_thread:
    598          #
    599          # Must take care to not raise an exception if dummy_thread is being
    600          # used (and thus this module is being used as an instance of
    601          # dummy_threading).  dummy_thread.get_ident() always returns -1 since
    602          # there is only one thread if dummy_thread is being used.  Thus
    603          # len(_active) is always <= 1 here, and any Thread instance created
    604          # overwrites the (if any) thread currently registered in _active.
    605          #
    606          # An instance of _MainThread is always created by 'threading'.  This
    607          # gets overwritten the instant an instance of Thread is created; both
    608          # threads return -1 from dummy_thread.get_ident() and thus have the
    609          # same key in the dict.  So when the _MainThread instance created by
    610          # 'threading' tries to clean itself up when atexit calls this method
    611          # it gets a KeyError if another Thread instance was created.
    612          #
    613          # This all means that KeyError from trying to delete something from
    614          # _active if dummy_threading is being used is a red herring.  But
    615          # since it isn't if dummy_threading is *not* being used then don't
    616          # hide the exception.
    617
    618          try:
    619              with _active_limbo_lock:
    620                  del _active[_get_ident()]
    621                  # There must not be any python code between the previous line
    622                  # and after the lock is released.  Otherwise a tracing function
    623                  # could try to acquire the lock again in the same thread, (in
    624                  # current_thread()), and would block.
    625          except KeyError:
    626              if 'dummy_threading' not in _sys.modules:
    627                  raise
    628
    629 -    def join(self, timeout=None):
    630          if not self.__initialized:
    631              raise RuntimeError("Thread.__init__() not called")
    632          if not self.__started.is_set():
    633              raise RuntimeError("cannot join thread before it is started")
    634          if self is current_thread():
    635              raise RuntimeError("cannot join current thread")
    636
    637          if __debug__:
    638              if not self.__stopped:
    639                  self._note("%s.join(): waiting until thread stops", self)
    640          self.__block.acquire()
    641          try:
    642              if timeout is None:
    643                  while not self.__stopped:
    644                      self.__block.wait()
    645                  if __debug__:
    646                      self._note("%s.join(): thread stopped", self)
    647              else:
    648                  deadline = _time() + timeout
    649                  while not self.__stopped:
    650                      delay = deadline - _time()
    651                      if delay <= 0:
    652                          if __debug__:
    653                              self._note("%s.join(): timed out", self)
    654                          break
    655                      self.__block.wait(delay)
    656                  else:
    657                      if __debug__:
    658                          self._note("%s.join(): thread stopped", self)
    659          finally:
    660              self.__block.release()
    661
    662      @property
    663 -    def name(self):
    664          assert self.__initialized, "Thread.__init__() not called"
    665          return self.__name
    666
    667      @name.setter
    668 -    def name(self, name):
    669          assert self.__initialized, "Thread.__init__() not called"
    670          self.__name = str(name)
    671
    672      @property
    673 -    def ident(self):
    674          assert self.__initialized, "Thread.__init__() not called"
    675          return self.__ident
    676
    677 -    def isAlive(self):
    678          assert self.__initialized, "Thread.__init__() not called"
    679          return self.__started.is_set() and not self.__stopped
    680
    681      is_alive = isAlive
    682
    683      @property
    684 -    def daemon(self):
    685          assert self.__initialized, "Thread.__init__() not called"
    686          return self.__daemonic
    687
    688      @daemon.setter
    689 -    def daemon(self, daemonic):
    690          if not self.__initialized:
    691              raise RuntimeError("Thread.__init__() not called")
    692          if self.__started.is_set():
    693              raise RuntimeError("cannot set daemon status of active thread");
    694          self.__daemonic = daemonic
    695
    696 -    def isDaemon(self):
    697          return self.daemon
    698
    699 -    def setDaemon(self, daemonic):
    700          self.daemon = daemonic
    701
    702 -    def getName(self):
    703          return self.name
    704
    705 -    def setName(self, name):
    706          self.name = name
    707
    708  # The timer class was contributed by Itamar Shtull-Trauring
    709
    710 -def Timer(*args, **kwargs):
    711      return _Timer(*args, **kwargs)
    712
    713 -class _Timer(Thread):
    714      """Call a function after a specified number of seconds:
    715
    716      t = Timer(30.0, f, args=[], kwargs={})
    717      t.start()
    718      t.cancel() # stop the timer's action if it's still waiting
    719      """
    720
    721 -    def __init__(self, interval, function, args=[], kwargs={}):
    722          Thread.__init__(self)
    723          self.interval = interval
    724          self.function = function
    725          self.args = args
    726          self.kwargs = kwargs
    727          self.finished = Event()
    728
    729 -    def cancel(self):
    730          """Stop the timer if it hasn't finished yet"""
    731          self.finished.set()
    732
    733 -    def run(self):
    734          self.finished.wait(self.interval)
    735          if not self.finished.is_set():
    736              self.function(*self.args, **self.kwargs)
    737          self.finished.set()
    738
    739  # Special thread class to represent the main thread
    740  # This is garbage collected through an exit handler
    741
    742 -class _MainThread(Thread):
    743
    744 -    def waitForThreadsOnExit(self):
    745          return True
    746
    747 -    def __init__(self):
    748          Thread.__init__(self, name="MainThread")
    749          self._Thread__started.set()
    750          self._set_ident()
    751          self.waitForThreadsOnExitFunc = self.waitForThreadsOnExit
    752          _active_limbo_lock.acquire()
    753          _active[_get_ident()] = self
    754          _active_limbo_lock.release()
    755
    756 -    def _set_daemon(self):
    757          return False
    758
    759 -    def _exitfunc(self):
    760          self._Thread__stop()
    761
    762          t = _pickSomeNonDaemonThread()
    763          if t:
    764              wait = self.waitForThreadsOnExitFunc()
    765              if wait and __debug__:
    766                  self._note("%s: waiting for other threads", self)
    767          while t and wait:
    768              t.join()
    769              t = _pickSomeNonDaemonThread()
    770          if __debug__:
    771              self._note("%s: exiting", self)
    772
    773          self._Thread__delete()
    774
    775 -def _pickSomeNonDaemonThread():
    776      for t in enumerate():
    777          if not t.daemon and t.is_alive():
    778              return t
    779      return None
    780
    781
    782  # Dummy thread class to represent threads not started here.
    783  # These aren't garbage collected when they die, nor can they be waited for.
    784  # If they invoke anything in threading.py that calls current_thread(), they
    785  # leave an entry in the _active dict forever after.
    786  # Their purpose is to return *something* from current_thread().
    787  # They are marked as daemon threads so we won't wait for them
    788  # when we exit (conform previous semantics).
    789
    790 -class _DummyThread(Thread):
    791
    792 -    def __init__(self):
    793          Thread.__init__(self, name=_newname("Dummy-%d"))
    794
    795          # Thread.__block consumes an OS-level locking primitive, which
    796          # can never be used by a _DummyThread.  Since a _DummyThread
    797          # instance is immortal, that's bad, so release this resource.
    798          del self._Thread__block
    799
    800          self._Thread__started.set()
    801          self._set_ident()
    802          _active_limbo_lock.acquire()
    803          _active[_get_ident()] = self
    804          _active_limbo_lock.release()
    805
    806 -    def _set_daemon(self):
    807          return True
    808
    809 -    def join(self, timeout=None):
    810          assert False, "cannot join a dummy thread"
    811
    812
    813  # Global API functions
    814
    815 -def currentThread():
    816      try:
    817          return _active[_get_ident()]
    818      except KeyError:
    819          ##print "current_thread(): no current thread for", _get_ident()
    820          return _DummyThread()
    821
    822  current_thread = currentThread
    823
    824 -def activeCount():
    825      _active_limbo_lock.acquire()
    826      count = len(_active) + len(_limbo)
    827      _active_limbo_lock.release()
    828      return count
    829
    830  active_count = activeCount
    831
    832 -def _enumerate():
    833      # Same as enumerate(), but without the lock. Internal use only.
    834      return _active.values() + _limbo.values()
    835
    836 -def enumerate():
    837      _active_limbo_lock.acquire()
    838      active = _active.values() + _limbo.values()
    839      _active_limbo_lock.release()
    840      return active
    841
    842  from thread import stack_size
    843
    844  # Create the main thread object,
    845  # and make it available for the interpreter
    846  # (Py_Main) as threading._shutdown.
    847
    848  _shutdown = _MainThread()._exitfunc
    849
    850  # get thread-local implementation, either from the thread
    851  # module, or from the python fallback
    852
    853  try:
    854      from thread import _local as local
    855  except ImportError:
    856      from _threading_local import local
    857
    858
    859 -def _after_fork():
    860      # This function is called by Python/ceval.c:PyEval_ReInitThreads which
    861      # is called from PyOS_AfterFork.  Here we cleanup threading module state
    862      # that should not exist after a fork.
    863
    864      # Reset _active_limbo_lock, in case we forked while the lock was held
    865      # by another (non-forked) thread.  http://bugs.python.org/issue874900
    866      global _active_limbo_lock
    867      _active_limbo_lock = _allocate_lock()
    868
    869      # fork() only copied the current thread; clear references to others.
    870      new_active = {}
    871      current = current_thread()
    872      with _active_limbo_lock:
    873          for thread in _active.itervalues():
    874              if thread is current:
    875                  # There is only one active thread. We reset the ident to
    876                  # its new value since it can have changed.
    877                  ident = _get_ident()
    878                  thread._Thread__ident = ident
    879                  new_active[ident] = thread
    880              else:
    881                  # All the others are already stopped.
    882                  # We don't call _Thread__stop() because it tries to acquire
    883                  # thread._Thread__block which could also have been held while
    884                  # we forked.
    885                  thread._Thread__stopped = True
    886
    887          _limbo.clear()
    888          _active.clear()
    889          _active.update(new_active)
    890          assert len(_active) == 1
    891
    892
    893  # Self-test code
    894
    895 -def _test():
    896
    897      class BoundedQueue(_Verbose):
    898
    899          def __init__(self, limit):
    900              _Verbose.__init__(self)
    901              self.mon = RLock()
    902              self.rc = Condition(self.mon)
    903              self.wc = Condition(self.mon)
    904              self.limit = limit
    905              self.queue = deque()
    906
    907          def put(self, item):
    908              self.mon.acquire()
    909              while len(self.queue) >= self.limit:
    910                  self._note("put(%s): queue full", item)
    911                  self.wc.wait()
    912              self.queue.append(item)
    913              self._note("put(%s): appended, length now %d",
    914                         item, len(self.queue))
    915              self.rc.notify()
    916              self.mon.release()
    917
    918          def get(self):
    919              self.mon.acquire()
    920              while not self.queue:
    921                  self._note("get(): queue empty")
    922                  self.rc.wait()
    923              item = self.queue.popleft()
    924              self._note("get(): got %s, %d left", item, len(self.queue))
    925              self.wc.notify()
    926              self.mon.release()
    927              return item
    928
    929      class ProducerThread(Thread):
    930
    931          def __init__(self, queue, quota):
    932              Thread.__init__(self, name="Producer")
    933              self.queue = queue
    934              self.quota = quota
    935
    936          def run(self):
    937              from random import random
    938              counter = 0
    939              while counter < self.quota:
    940                  counter = counter + 1
    941                  self.queue.put("%s.%d" % (self.name, counter))
    942                  _sleep(random() * 0.00001)
    943
    944
    945      class ConsumerThread(Thread):
    946
    947          def __init__(self, queue, count):
    948              Thread.__init__(self, name="Consumer")
    949              self.queue = queue
    950              self.count = count
    951
    952          def run(self):
    953              while self.count > 0:
    954                  item = self.queue.get()
    955                  print item
    956                  self.count = self.count - 1
    957
    958      NP = 3
    959      QL = 4
    960      NI = 5
    961
    962      Q = BoundedQueue(QL)
    963      P = []
    964      for i in range(NP):
    965          t = ProducerThread(Q, NI)
    966          t.name = ("Producer-%d" % (i+1))
    967          P.append(t)
    968      C = ConsumerThread(Q, NI*NP)
    969      for t in P:
    970          t.start()
    971          _sleep(0.000001)
    972      C.start()
    973      for t in P:
    974          t.join()
    975      C.join()
    976
    977  if __name__ == '__main__':
    978      _test()
    979