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

Source Code for Module threading