1"""Thread module emulating a subset of Java's threading model.""" 2 3import os as _os 4import sys as _sys 5import _thread 6import functools 7 8from time import monotonic as _time 9from _weakrefset import WeakSet 10from itertools import islice as _islice, count as _count 11try: 12 from _collections import deque as _deque 13except ImportError: 14 from collections import deque as _deque 15 16# Note regarding PEP 8 compliant names 17# This threading model was originally inspired by Java, and inherited 18# the convention of camelCase function and method names from that 19# language. Those original names are not in any imminent danger of 20# being deprecated (even for Py3k),so this module provides them as an 21# alias for the PEP 8 compliant names 22# Note that using the new PEP 8 compliant names facilitates substitution 23# with the multiprocessing module, which doesn't provide the old 24# Java inspired names. 25 26__all__ = ['get_ident', 'active_count', 'Condition', 'current_thread', 27 'enumerate', 'main_thread', 'TIMEOUT_MAX', 28 'Event', 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread', 29 'Barrier', 'BrokenBarrierError', 'Timer', 'ThreadError', 30 'setprofile', 'settrace', 'local', 'stack_size', 31 'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile'] 32 33# Rename some stuff so "from threading import *" is safe 34_start_new_thread = _thread.start_new_thread 35_allocate_lock = _thread.allocate_lock 36_set_sentinel = _thread._set_sentinel 37get_ident = _thread.get_ident 38try: 39 get_native_id = _thread.get_native_id 40 _HAVE_THREAD_NATIVE_ID = True 41 __all__.append('get_native_id') 42except AttributeError: 43 _HAVE_THREAD_NATIVE_ID = False 44ThreadError = _thread.error 45try: 46 _CRLock = _thread.RLock 47except AttributeError: 48 _CRLock = None 49TIMEOUT_MAX = _thread.TIMEOUT_MAX 50del _thread 51 52 53# Support for profile and trace hooks 54 55_profile_hook = None 56_trace_hook = None 57 58def setprofile(func): 59 """Set a profile function for all threads started from the threading module. 60 61 The func will be passed to sys.setprofile() for each thread, before its 62 run() method is called. 63 64 """ 65 global _profile_hook 66 _profile_hook = func 67 68def getprofile(): 69 """Get the profiler function as set by threading.setprofile().""" 70 return _profile_hook 71 72def settrace(func): 73 """Set a trace function for all threads started from the threading module. 74 75 The func will be passed to sys.settrace() for each thread, before its run() 76 method is called. 77 78 """ 79 global _trace_hook 80 _trace_hook = func 81 82def gettrace(): 83 """Get the trace function as set by threading.settrace().""" 84 return _trace_hook 85 86# Synchronization classes 87 88Lock = _allocate_lock 89 90def RLock(*args, **kwargs): 91 """Factory function that returns a new reentrant lock. 92 93 A reentrant lock must be released by the thread that acquired it. Once a 94 thread has acquired a reentrant lock, the same thread may acquire it again 95 without blocking; the thread must release it once for each time it has 96 acquired it. 97 98 """ 99 if _CRLock is None: 100 return _PyRLock(*args, **kwargs) 101 return _CRLock(*args, **kwargs) 102 103class _RLock: 104 """This class implements reentrant lock objects. 105 106 A reentrant lock must be released by the thread that acquired it. Once a 107 thread has acquired a reentrant lock, the same thread may acquire it 108 again without blocking; the thread must release it once for each time it 109 has acquired it. 110 111 """ 112 113 def __init__(self): 114 self._block = _allocate_lock() 115 self._owner = None 116 self._count = 0 117 118 def __repr__(self): 119 owner = self._owner 120 try: 121 owner = _active[owner].name 122 except KeyError: 123 pass 124 return "<%s %s.%s object owner=%r count=%d at %s>" % ( 125 "locked" if self._block.locked() else "unlocked", 126 self.__class__.__module__, 127 self.__class__.__qualname__, 128 owner, 129 self._count, 130 hex(id(self)) 131 ) 132 133 def _at_fork_reinit(self): 134 self._block._at_fork_reinit() 135 self._owner = None 136 self._count = 0 137 138 def acquire(self, blocking=True, timeout=-1): 139 """Acquire a lock, blocking or non-blocking. 140 141 When invoked without arguments: if this thread already owns the lock, 142 increment the recursion level by one, and return immediately. Otherwise, 143 if another thread owns the lock, block until the lock is unlocked. Once 144 the lock is unlocked (not owned by any thread), then grab ownership, set 145 the recursion level to one, and return. If more than one thread is 146 blocked waiting until the lock is unlocked, only one at a time will be 147 able to grab ownership of the lock. There is no return value in this 148 case. 149 150 When invoked with the blocking argument set to true, do the same thing 151 as when called without arguments, and return true. 152 153 When invoked with the blocking argument set to false, do not block. If a 154 call without an argument would block, return false immediately; 155 otherwise, do the same thing as when called without arguments, and 156 return true. 157 158 When invoked with the floating-point timeout argument set to a positive 159 value, block for at most the number of seconds specified by timeout 160 and as long as the lock cannot be acquired. Return true if the lock has 161 been acquired, false if the timeout has elapsed. 162 163 """ 164 me = get_ident() 165 if self._owner == me: 166 self._count += 1 167 return 1 168 rc = self._block.acquire(blocking, timeout) 169 if rc: 170 self._owner = me 171 self._count = 1 172 return rc 173 174 __enter__ = acquire 175 176 def release(self): 177 """Release a lock, decrementing the recursion level. 178 179 If after the decrement it is zero, reset the lock to unlocked (not owned 180 by any thread), and if any other threads are blocked waiting for the 181 lock to become unlocked, allow exactly one of them to proceed. If after 182 the decrement the recursion level is still nonzero, the lock remains 183 locked and owned by the calling thread. 184 185 Only call this method when the calling thread owns the lock. A 186 RuntimeError is raised if this method is called when the lock is 187 unlocked. 188 189 There is no return value. 190 191 """ 192 if self._owner != get_ident(): 193 raise RuntimeError("cannot release un-acquired lock") 194 self._count = count = self._count - 1 195 if not count: 196 self._owner = None 197 self._block.release() 198 199 def __exit__(self, t, v, tb): 200 self.release() 201 202 # Internal methods used by condition variables 203 204 def _acquire_restore(self, state): 205 self._block.acquire() 206 self._count, self._owner = state 207 208 def _release_save(self): 209 if self._count == 0: 210 raise RuntimeError("cannot release un-acquired lock") 211 count = self._count 212 self._count = 0 213 owner = self._owner 214 self._owner = None 215 self._block.release() 216 return (count, owner) 217 218 def _is_owned(self): 219 return self._owner == get_ident() 220 221_PyRLock = _RLock 222 223 224class Condition: 225 """Class that implements a condition variable. 226 227 A condition variable allows one or more threads to wait until they are 228 notified by another thread. 229 230 If the lock argument is given and not None, it must be a Lock or RLock 231 object, and it is used as the underlying lock. Otherwise, a new RLock object 232 is created and used as the underlying lock. 233 234 """ 235 236 def __init__(self, lock=None): 237 if lock is None: 238 lock = RLock() 239 self._lock = lock 240 # Export the lock's acquire() and release() methods 241 self.acquire = lock.acquire 242 self.release = lock.release 243 # If the lock defines _release_save() and/or _acquire_restore(), 244 # these override the default implementations (which just call 245 # release() and acquire() on the lock). Ditto for _is_owned(). 246 try: 247 self._release_save = lock._release_save 248 except AttributeError: 249 pass 250 try: 251 self._acquire_restore = lock._acquire_restore 252 except AttributeError: 253 pass 254 try: 255 self._is_owned = lock._is_owned 256 except AttributeError: 257 pass 258 self._waiters = _deque() 259 260 def _at_fork_reinit(self): 261 self._lock._at_fork_reinit() 262 self._waiters.clear() 263 264 def __enter__(self): 265 return self._lock.__enter__() 266 267 def __exit__(self, *args): 268 return self._lock.__exit__(*args) 269 270 def __repr__(self): 271 return "<Condition(%s, %d)>" % (self._lock, len(self._waiters)) 272 273 def _release_save(self): 274 self._lock.release() # No state to save 275 276 def _acquire_restore(self, x): 277 self._lock.acquire() # Ignore saved state 278 279 def _is_owned(self): 280 # Return True if lock is owned by current_thread. 281 # This method is called only if _lock doesn't have _is_owned(). 282 if self._lock.acquire(False): 283 self._lock.release() 284 return False 285 else: 286 return True 287 288 def wait(self, timeout=None): 289 """Wait until notified or until a timeout occurs. 290 291 If the calling thread has not acquired the lock when this method is 292 called, a RuntimeError is raised. 293 294 This method releases the underlying lock, and then blocks until it is 295 awakened by a notify() or notify_all() call for the same condition 296 variable in another thread, or until the optional timeout occurs. Once 297 awakened or timed out, it re-acquires the lock and returns. 298 299 When the timeout argument is present and not None, it should be a 300 floating point number specifying a timeout for the operation in seconds 301 (or fractions thereof). 302 303 When the underlying lock is an RLock, it is not released using its 304 release() method, since this may not actually unlock the lock when it 305 was acquired multiple times recursively. Instead, an internal interface 306 of the RLock class is used, which really unlocks it even when it has 307 been recursively acquired several times. Another internal interface is 308 then used to restore the recursion level when the lock is reacquired. 309 310 """ 311 if not self._is_owned(): 312 raise RuntimeError("cannot wait on un-acquired lock") 313 waiter = _allocate_lock() 314 waiter.acquire() 315 self._waiters.append(waiter) 316 saved_state = self._release_save() 317 gotit = False 318 try: # restore state no matter what (e.g., KeyboardInterrupt) 319 if timeout is None: 320 waiter.acquire() 321 gotit = True 322 else: 323 if timeout > 0: 324 gotit = waiter.acquire(True, timeout) 325 else: 326 gotit = waiter.acquire(False) 327 return gotit 328 finally: 329 self._acquire_restore(saved_state) 330 if not gotit: 331 try: 332 self._waiters.remove(waiter) 333 except ValueError: 334 pass 335 336 def wait_for(self, predicate, timeout=None): 337 """Wait until a condition evaluates to True. 338 339 predicate should be a callable which result will be interpreted as a 340 boolean value. A timeout may be provided giving the maximum time to 341 wait. 342 343 """ 344 endtime = None 345 waittime = timeout 346 result = predicate() 347 while not result: 348 if waittime is not None: 349 if endtime is None: 350 endtime = _time() + waittime 351 else: 352 waittime = endtime - _time() 353 if waittime <= 0: 354 break 355 self.wait(waittime) 356 result = predicate() 357 return result 358 359 def notify(self, n=1): 360 """Wake up one or more threads waiting on this condition, if any. 361 362 If the calling thread has not acquired the lock when this method is 363 called, a RuntimeError is raised. 364 365 This method wakes up at most n of the threads waiting for the condition 366 variable; it is a no-op if no threads are waiting. 367 368 """ 369 if not self._is_owned(): 370 raise RuntimeError("cannot notify on un-acquired lock") 371 all_waiters = self._waiters 372 waiters_to_notify = _deque(_islice(all_waiters, n)) 373 if not waiters_to_notify: 374 return 375 for waiter in waiters_to_notify: 376 waiter.release() 377 try: 378 all_waiters.remove(waiter) 379 except ValueError: 380 pass 381 382 def notify_all(self): 383 """Wake up all threads waiting on this condition. 384 385 If the calling thread has not acquired the lock when this method 386 is called, a RuntimeError is raised. 387 388 """ 389 self.notify(len(self._waiters)) 390 391 def notifyAll(self): 392 """Wake up all threads waiting on this condition. 393 394 This method is deprecated, use notify_all() instead. 395 396 """ 397 import warnings 398 warnings.warn('notifyAll() is deprecated, use notify_all() instead', 399 DeprecationWarning, stacklevel=2) 400 self.notify_all() 401 402 403class Semaphore: 404 """This class implements semaphore objects. 405 406 Semaphores manage a counter representing the number of release() calls minus 407 the number of acquire() calls, plus an initial value. The acquire() method 408 blocks if necessary until it can return without making the counter 409 negative. If not given, value defaults to 1. 410 411 """ 412 413 # After Tim Peters' semaphore class, but not quite the same (no maximum) 414 415 def __init__(self, value=1): 416 if value < 0: 417 raise ValueError("semaphore initial value must be >= 0") 418 self._cond = Condition(Lock()) 419 self._value = value 420 421 def acquire(self, blocking=True, timeout=None): 422 """Acquire a semaphore, decrementing the internal counter by one. 423 424 When invoked without arguments: if the internal counter is larger than 425 zero on entry, decrement it by one and return immediately. If it is zero 426 on entry, block, waiting until some other thread has called release() to 427 make it larger than zero. This is done with proper interlocking so that 428 if multiple acquire() calls are blocked, release() will wake exactly one 429 of them up. The implementation may pick one at random, so the order in 430 which blocked threads are awakened should not be relied on. There is no 431 return value in this case. 432 433 When invoked with blocking set to true, do the same thing as when called 434 without arguments, and return true. 435 436 When invoked with blocking set to false, do not block. If a call without 437 an argument would block, return false immediately; otherwise, do the 438 same thing as when called without arguments, and return true. 439 440 When invoked with a timeout other than None, it will block for at 441 most timeout seconds. If acquire does not complete successfully in 442 that interval, return false. Return true otherwise. 443 444 """ 445 if not blocking and timeout is not None: 446 raise ValueError("can't specify timeout for non-blocking acquire") 447 rc = False 448 endtime = None 449 with self._cond: 450 while self._value == 0: 451 if not blocking: 452 break 453 if timeout is not None: 454 if endtime is None: 455 endtime = _time() + timeout 456 else: 457 timeout = endtime - _time() 458 if timeout <= 0: 459 break 460 self._cond.wait(timeout) 461 else: 462 self._value -= 1 463 rc = True 464 return rc 465 466 __enter__ = acquire 467 468 def release(self, n=1): 469 """Release a semaphore, incrementing the internal counter by one or more. 470 471 When the counter is zero on entry and another thread is waiting for it 472 to become larger than zero again, wake up that thread. 473 474 """ 475 if n < 1: 476 raise ValueError('n must be one or more') 477 with self._cond: 478 self._value += n 479 for i in range(n): 480 self._cond.notify() 481 482 def __exit__(self, t, v, tb): 483 self.release() 484 485 486class BoundedSemaphore(Semaphore): 487 """Implements a bounded semaphore. 488 489 A bounded semaphore checks to make sure its current value doesn't exceed its 490 initial value. If it does, ValueError is raised. In most situations 491 semaphores are used to guard resources with limited capacity. 492 493 If the semaphore is released too many times it's a sign of a bug. If not 494 given, value defaults to 1. 495 496 Like regular semaphores, bounded semaphores manage a counter representing 497 the number of release() calls minus the number of acquire() calls, plus an 498 initial value. The acquire() method blocks if necessary until it can return 499 without making the counter negative. If not given, value defaults to 1. 500 501 """ 502 503 def __init__(self, value=1): 504 Semaphore.__init__(self, value) 505 self._initial_value = value 506 507 def release(self, n=1): 508 """Release a semaphore, incrementing the internal counter by one or more. 509 510 When the counter is zero on entry and another thread is waiting for it 511 to become larger than zero again, wake up that thread. 512 513 If the number of releases exceeds the number of acquires, 514 raise a ValueError. 515 516 """ 517 if n < 1: 518 raise ValueError('n must be one or more') 519 with self._cond: 520 if self._value + n > self._initial_value: 521 raise ValueError("Semaphore released too many times") 522 self._value += n 523 for i in range(n): 524 self._cond.notify() 525 526 527class Event: 528 """Class implementing event objects. 529 530 Events manage a flag that can be set to true with the set() method and reset 531 to false with the clear() method. The wait() method blocks until the flag is 532 true. The flag is initially false. 533 534 """ 535 536 # After Tim Peters' event class (without is_posted()) 537 538 def __init__(self): 539 self._cond = Condition(Lock()) 540 self._flag = False 541 542 def _at_fork_reinit(self): 543 # Private method called by Thread._reset_internal_locks() 544 self._cond._at_fork_reinit() 545 546 def is_set(self): 547 """Return true if and only if the internal flag is true.""" 548 return self._flag 549 550 def isSet(self): 551 """Return true if and only if the internal flag is true. 552 553 This method is deprecated, use notify_all() instead. 554 555 """ 556 import warnings 557 warnings.warn('isSet() is deprecated, use is_set() instead', 558 DeprecationWarning, stacklevel=2) 559 return self.is_set() 560 561 def set(self): 562 """Set the internal flag to true. 563 564 All threads waiting for it to become true are awakened. Threads 565 that call wait() once the flag is true will not block at all. 566 567 """ 568 with self._cond: 569 self._flag = True 570 self._cond.notify_all() 571 572 def clear(self): 573 """Reset the internal flag to false. 574 575 Subsequently, threads calling wait() will block until set() is called to 576 set the internal flag to true again. 577 578 """ 579 with self._cond: 580 self._flag = False 581 582 def wait(self, timeout=None): 583 """Block until the internal flag is true. 584 585 If the internal flag is true on entry, return immediately. Otherwise, 586 block until another thread calls set() to set the flag to true, or until 587 the optional timeout occurs. 588 589 When the timeout argument is present and not None, it should be a 590 floating point number specifying a timeout for the operation in seconds 591 (or fractions thereof). 592 593 This method returns the internal flag on exit, so it will always return 594 True except if a timeout is given and the operation times out. 595 596 """ 597 with self._cond: 598 signaled = self._flag 599 if not signaled: 600 signaled = self._cond.wait(timeout) 601 return signaled 602 603 604# A barrier class. Inspired in part by the pthread_barrier_* api and 605# the CyclicBarrier class from Java. See 606# http://sourceware.org/pthreads-win32/manual/pthread_barrier_init.html and 607# http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/ 608# CyclicBarrier.html 609# for information. 610# We maintain two main states, 'filling' and 'draining' enabling the barrier 611# to be cyclic. Threads are not allowed into it until it has fully drained 612# since the previous cycle. In addition, a 'resetting' state exists which is 613# similar to 'draining' except that threads leave with a BrokenBarrierError, 614# and a 'broken' state in which all threads get the exception. 615class Barrier: 616 """Implements a Barrier. 617 618 Useful for synchronizing a fixed number of threads at known synchronization 619 points. Threads block on 'wait()' and are simultaneously awoken once they 620 have all made that call. 621 622 """ 623 624 def __init__(self, parties, action=None, timeout=None): 625 """Create a barrier, initialised to 'parties' threads. 626 627 'action' is a callable which, when supplied, will be called by one of 628 the threads after they have all entered the barrier and just prior to 629 releasing them all. If a 'timeout' is provided, it is used as the 630 default for all subsequent 'wait()' calls. 631 632 """ 633 self._cond = Condition(Lock()) 634 self._action = action 635 self._timeout = timeout 636 self._parties = parties 637 self._state = 0 # 0 filling, 1 draining, -1 resetting, -2 broken 638 self._count = 0 639 640 def wait(self, timeout=None): 641 """Wait for the barrier. 642 643 When the specified number of threads have started waiting, they are all 644 simultaneously awoken. If an 'action' was provided for the barrier, one 645 of the threads will have executed that callback prior to returning. 646 Returns an individual index number from 0 to 'parties-1'. 647 648 """ 649 if timeout is None: 650 timeout = self._timeout 651 with self._cond: 652 self._enter() # Block while the barrier drains. 653 index = self._count 654 self._count += 1 655 try: 656 if index + 1 == self._parties: 657 # We release the barrier 658 self._release() 659 else: 660 # We wait until someone releases us 661 self._wait(timeout) 662 return index 663 finally: 664 self._count -= 1 665 # Wake up any threads waiting for barrier to drain. 666 self._exit() 667 668 # Block until the barrier is ready for us, or raise an exception 669 # if it is broken. 670 def _enter(self): 671 while self._state in (-1, 1): 672 # It is draining or resetting, wait until done 673 self._cond.wait() 674 #see if the barrier is in a broken state 675 if self._state < 0: 676 raise BrokenBarrierError 677 assert self._state == 0 678 679 # Optionally run the 'action' and release the threads waiting 680 # in the barrier. 681 def _release(self): 682 try: 683 if self._action: 684 self._action() 685 # enter draining state 686 self._state = 1 687 self._cond.notify_all() 688 except: 689 #an exception during the _action handler. Break and reraise 690 self._break() 691 raise 692 693 # Wait in the barrier until we are released. Raise an exception 694 # if the barrier is reset or broken. 695 def _wait(self, timeout): 696 if not self._cond.wait_for(lambda : self._state != 0, timeout): 697 #timed out. Break the barrier 698 self._break() 699 raise BrokenBarrierError 700 if self._state < 0: 701 raise BrokenBarrierError 702 assert self._state == 1 703 704 # If we are the last thread to exit the barrier, signal any threads 705 # waiting for the barrier to drain. 706 def _exit(self): 707 if self._count == 0: 708 if self._state in (-1, 1): 709 #resetting or draining 710 self._state = 0 711 self._cond.notify_all() 712 713 def reset(self): 714 """Reset the barrier to the initial state. 715 716 Any threads currently waiting will get the BrokenBarrier exception 717 raised. 718 719 """ 720 with self._cond: 721 if self._count > 0: 722 if self._state == 0: 723 #reset the barrier, waking up threads 724 self._state = -1 725 elif self._state == -2: 726 #was broken, set it to reset state 727 #which clears when the last thread exits 728 self._state = -1 729 else: 730 self._state = 0 731 self._cond.notify_all() 732 733 def abort(self): 734 """Place the barrier into a 'broken' state. 735 736 Useful in case of error. Any currently waiting threads and threads 737 attempting to 'wait()' will have BrokenBarrierError raised. 738 739 """ 740 with self._cond: 741 self._break() 742 743 def _break(self): 744 # An internal error was detected. The barrier is set to 745 # a broken state all parties awakened. 746 self._state = -2 747 self._cond.notify_all() 748 749 @property 750 def parties(self): 751 """Return the number of threads required to trip the barrier.""" 752 return self._parties 753 754 @property 755 def n_waiting(self): 756 """Return the number of threads currently waiting at the barrier.""" 757 # We don't need synchronization here since this is an ephemeral result 758 # anyway. It returns the correct value in the steady state. 759 if self._state == 0: 760 return self._count 761 return 0 762 763 @property 764 def broken(self): 765 """Return True if the barrier is in a broken state.""" 766 return self._state == -2 767 768# exception raised by the Barrier class 769class BrokenBarrierError(RuntimeError): 770 pass 771 772 773# Helper to generate new thread names 774_counter = _count(1).__next__ 775def _newname(name_template): 776 return name_template % _counter() 777 778# Active thread administration. 779# 780# bpo-44422: Use a reentrant lock to allow reentrant calls to functions like 781# threading.enumerate(). 782_active_limbo_lock = RLock() 783_active = {} # maps thread id to Thread object 784_limbo = {} 785_dangling = WeakSet() 786 787# Set of Thread._tstate_lock locks of non-daemon threads used by _shutdown() 788# to wait until all Python thread states get deleted: 789# see Thread._set_tstate_lock(). 790_shutdown_locks_lock = _allocate_lock() 791_shutdown_locks = set() 792 793def _maintain_shutdown_locks(): 794 """ 795 Drop any shutdown locks that don't correspond to running threads anymore. 796 797 Calling this from time to time avoids an ever-growing _shutdown_locks 798 set when Thread objects are not joined explicitly. See bpo-37788. 799 800 This must be called with _shutdown_locks_lock acquired. 801 """ 802 # If a lock was released, the corresponding thread has exited 803 to_remove = [lock for lock in _shutdown_locks if not lock.locked()] 804 _shutdown_locks.difference_update(to_remove) 805 806 807# Main class for threads 808 809class Thread: 810 """A class that represents a thread of control. 811 812 This class can be safely subclassed in a limited fashion. There are two ways 813 to specify the activity: by passing a callable object to the constructor, or 814 by overriding the run() method in a subclass. 815 816 """ 817 818 _initialized = False 819 820 def __init__(self, group=None, target=None, name=None, 821 args=(), kwargs=None, *, daemon=None): 822 """This constructor should always be called with keyword arguments. Arguments are: 823 824 *group* should be None; reserved for future extension when a ThreadGroup 825 class is implemented. 826 827 *target* is the callable object to be invoked by the run() 828 method. Defaults to None, meaning nothing is called. 829 830 *name* is the thread name. By default, a unique name is constructed of 831 the form "Thread-N" where N is a small decimal number. 832 833 *args* is the argument tuple for the target invocation. Defaults to (). 834 835 *kwargs* is a dictionary of keyword arguments for the target 836 invocation. Defaults to {}. 837 838 If a subclass overrides the constructor, it must make sure to invoke 839 the base class constructor (Thread.__init__()) before doing anything 840 else to the thread. 841 842 """ 843 assert group is None, "group argument must be None for now" 844 if kwargs is None: 845 kwargs = {} 846 if name: 847 name = str(name) 848 else: 849 name = _newname("Thread-%d") 850 if target is not None: 851 try: 852 target_name = target.__name__ 853 name += f" ({target_name})" 854 except AttributeError: 855 pass 856 857 self._target = target 858 self._name = name 859 self._args = args 860 self._kwargs = kwargs 861 if daemon is not None: 862 self._daemonic = daemon 863 else: 864 self._daemonic = current_thread().daemon 865 self._ident = None 866 if _HAVE_THREAD_NATIVE_ID: 867 self._native_id = None 868 self._tstate_lock = None 869 self._started = Event() 870 self._is_stopped = False 871 self._initialized = True 872 # Copy of sys.stderr used by self._invoke_excepthook() 873 self._stderr = _sys.stderr 874 self._invoke_excepthook = _make_invoke_excepthook() 875 # For debugging and _after_fork() 876 _dangling.add(self) 877 878 def _reset_internal_locks(self, is_alive): 879 # private! Called by _after_fork() to reset our internal locks as 880 # they may be in an invalid state leading to a deadlock or crash. 881 self._started._at_fork_reinit() 882 if is_alive: 883 # bpo-42350: If the fork happens when the thread is already stopped 884 # (ex: after threading._shutdown() has been called), _tstate_lock 885 # is None. Do nothing in this case. 886 if self._tstate_lock is not None: 887 self._tstate_lock._at_fork_reinit() 888 self._tstate_lock.acquire() 889 else: 890 # The thread isn't alive after fork: it doesn't have a tstate 891 # anymore. 892 self._is_stopped = True 893 self._tstate_lock = None 894 895 def __repr__(self): 896 assert self._initialized, "Thread.__init__() was not called" 897 status = "initial" 898 if self._started.is_set(): 899 status = "started" 900 self.is_alive() # easy way to get ._is_stopped set when appropriate 901 if self._is_stopped: 902 status = "stopped" 903 if self._daemonic: 904 status += " daemon" 905 if self._ident is not None: 906 status += " %s" % self._ident 907 return "<%s(%s, %s)>" % (self.__class__.__name__, self._name, status) 908 909 def start(self): 910 """Start the thread's activity. 911 912 It must be called at most once per thread object. It arranges for the 913 object's run() method to be invoked in a separate thread of control. 914 915 This method will raise a RuntimeError if called more than once on the 916 same thread object. 917 918 """ 919 if not self._initialized: 920 raise RuntimeError("thread.__init__() not called") 921 922 if self._started.is_set(): 923 raise RuntimeError("threads can only be started once") 924 925 with _active_limbo_lock: 926 _limbo[self] = self 927 try: 928 _start_new_thread(self._bootstrap, ()) 929 except Exception: 930 with _active_limbo_lock: 931 del _limbo[self] 932 raise 933 self._started.wait() 934 935 def run(self): 936 """Method representing the thread's activity. 937 938 You may override this method in a subclass. The standard run() method 939 invokes the callable object passed to the object's constructor as the 940 target argument, if any, with sequential and keyword arguments taken 941 from the args and kwargs arguments, respectively. 942 943 """ 944 try: 945 if self._target is not None: 946 self._target(*self._args, **self._kwargs) 947 finally: 948 # Avoid a refcycle if the thread is running a function with 949 # an argument that has a member that points to the thread. 950 del self._target, self._args, self._kwargs 951 952 def _bootstrap(self): 953 # Wrapper around the real bootstrap code that ignores 954 # exceptions during interpreter cleanup. Those typically 955 # happen when a daemon thread wakes up at an unfortunate 956 # moment, finds the world around it destroyed, and raises some 957 # random exception *** while trying to report the exception in 958 # _bootstrap_inner() below ***. Those random exceptions 959 # don't help anybody, and they confuse users, so we suppress 960 # them. We suppress them only when it appears that the world 961 # indeed has already been destroyed, so that exceptions in 962 # _bootstrap_inner() during normal business hours are properly 963 # reported. Also, we only suppress them for daemonic threads; 964 # if a non-daemonic encounters this, something else is wrong. 965 try: 966 self._bootstrap_inner() 967 except: 968 if self._daemonic and _sys is None: 969 return 970 raise 971 972 def _set_ident(self): 973 self._ident = get_ident() 974 975 if _HAVE_THREAD_NATIVE_ID: 976 def _set_native_id(self): 977 self._native_id = get_native_id() 978 979 def _set_tstate_lock(self): 980 """ 981 Set a lock object which will be released by the interpreter when 982 the underlying thread state (see pystate.h) gets deleted. 983 """ 984 self._tstate_lock = _set_sentinel() 985 self._tstate_lock.acquire() 986 987 if not self.daemon: 988 with _shutdown_locks_lock: 989 _maintain_shutdown_locks() 990 _shutdown_locks.add(self._tstate_lock) 991 992 def _bootstrap_inner(self): 993 try: 994 self._set_ident() 995 self._set_tstate_lock() 996 if _HAVE_THREAD_NATIVE_ID: 997 self._set_native_id() 998 self._started.set() 999 with _active_limbo_lock: 1000 _active[self._ident] = self 1001 del _limbo[self] 1002 1003 if _trace_hook: 1004 _sys.settrace(_trace_hook) 1005 if _profile_hook: 1006 _sys.setprofile(_profile_hook) 1007 1008 try: 1009 self.run() 1010 except: 1011 self._invoke_excepthook(self) 1012 finally: 1013 with _active_limbo_lock: 1014 try: 1015 # We don't call self._delete() because it also 1016 # grabs _active_limbo_lock. 1017 del _active[get_ident()] 1018 except: 1019 pass 1020 1021 def _stop(self): 1022 # After calling ._stop(), .is_alive() returns False and .join() returns 1023 # immediately. ._tstate_lock must be released before calling ._stop(). 1024 # 1025 # Normal case: C code at the end of the thread's life 1026 # (release_sentinel in _threadmodule.c) releases ._tstate_lock, and 1027 # that's detected by our ._wait_for_tstate_lock(), called by .join() 1028 # and .is_alive(). Any number of threads _may_ call ._stop() 1029 # simultaneously (for example, if multiple threads are blocked in 1030 # .join() calls), and they're not serialized. That's harmless - 1031 # they'll just make redundant rebindings of ._is_stopped and 1032 # ._tstate_lock. Obscure: we rebind ._tstate_lock last so that the 1033 # "assert self._is_stopped" in ._wait_for_tstate_lock() always works 1034 # (the assert is executed only if ._tstate_lock is None). 1035 # 1036 # Special case: _main_thread releases ._tstate_lock via this 1037 # module's _shutdown() function. 1038 lock = self._tstate_lock 1039 if lock is not None: 1040 assert not lock.locked() 1041 self._is_stopped = True 1042 self._tstate_lock = None 1043 if not self.daemon: 1044 with _shutdown_locks_lock: 1045 # Remove our lock and other released locks from _shutdown_locks 1046 _maintain_shutdown_locks() 1047 1048 def _delete(self): 1049 "Remove current thread from the dict of currently running threads." 1050 with _active_limbo_lock: 1051 del _active[get_ident()] 1052 # There must not be any python code between the previous line 1053 # and after the lock is released. Otherwise a tracing function 1054 # could try to acquire the lock again in the same thread, (in 1055 # current_thread()), and would block. 1056 1057 def join(self, timeout=None): 1058 """Wait until the thread terminates. 1059 1060 This blocks the calling thread until the thread whose join() method is 1061 called terminates -- either normally or through an unhandled exception 1062 or until the optional timeout occurs. 1063 1064 When the timeout argument is present and not None, it should be a 1065 floating point number specifying a timeout for the operation in seconds 1066 (or fractions thereof). As join() always returns None, you must call 1067 is_alive() after join() to decide whether a timeout happened -- if the 1068 thread is still alive, the join() call timed out. 1069 1070 When the timeout argument is not present or None, the operation will 1071 block until the thread terminates. 1072 1073 A thread can be join()ed many times. 1074 1075 join() raises a RuntimeError if an attempt is made to join the current 1076 thread as that would cause a deadlock. It is also an error to join() a 1077 thread before it has been started and attempts to do so raises the same 1078 exception. 1079 1080 """ 1081 if not self._initialized: 1082 raise RuntimeError("Thread.__init__() not called") 1083 if not self._started.is_set(): 1084 raise RuntimeError("cannot join thread before it is started") 1085 if self is current_thread(): 1086 raise RuntimeError("cannot join current thread") 1087 1088 if timeout is None: 1089 self._wait_for_tstate_lock() 1090 else: 1091 # the behavior of a negative timeout isn't documented, but 1092 # historically .join(timeout=x) for x<0 has acted as if timeout=0 1093 self._wait_for_tstate_lock(timeout=max(timeout, 0)) 1094 1095 def _wait_for_tstate_lock(self, block=True, timeout=-1): 1096 # Issue #18808: wait for the thread state to be gone. 1097 # At the end of the thread's life, after all knowledge of the thread 1098 # is removed from C data structures, C code releases our _tstate_lock. 1099 # This method passes its arguments to _tstate_lock.acquire(). 1100 # If the lock is acquired, the C code is done, and self._stop() is 1101 # called. That sets ._is_stopped to True, and ._tstate_lock to None. 1102 lock = self._tstate_lock 1103 if lock is None: 1104 # already determined that the C code is done 1105 assert self._is_stopped 1106 return 1107 1108 try: 1109 if lock.acquire(block, timeout): 1110 lock.release() 1111 self._stop() 1112 except: 1113 if lock.locked(): 1114 # bpo-45274: lock.acquire() acquired the lock, but the function 1115 # was interrupted with an exception before reaching the 1116 # lock.release(). It can happen if a signal handler raises an 1117 # exception, like CTRL+C which raises KeyboardInterrupt. 1118 lock.release() 1119 self._stop() 1120 raise 1121 1122 @property 1123 def name(self): 1124 """A string used for identification purposes only. 1125 1126 It has no semantics. Multiple threads may be given the same name. The 1127 initial name is set by the constructor. 1128 1129 """ 1130 assert self._initialized, "Thread.__init__() not called" 1131 return self._name 1132 1133 @name.setter 1134 def name(self, name): 1135 assert self._initialized, "Thread.__init__() not called" 1136 self._name = str(name) 1137 1138 @property 1139 def ident(self): 1140 """Thread identifier of this thread or None if it has not been started. 1141 1142 This is a nonzero integer. See the get_ident() function. Thread 1143 identifiers may be recycled when a thread exits and another thread is 1144 created. The identifier is available even after the thread has exited. 1145 1146 """ 1147 assert self._initialized, "Thread.__init__() not called" 1148 return self._ident 1149 1150 if _HAVE_THREAD_NATIVE_ID: 1151 @property 1152 def native_id(self): 1153 """Native integral thread ID of this thread, or None if it has not been started. 1154 1155 This is a non-negative integer. See the get_native_id() function. 1156 This represents the Thread ID as reported by the kernel. 1157 1158 """ 1159 assert self._initialized, "Thread.__init__() not called" 1160 return self._native_id 1161 1162 def is_alive(self): 1163 """Return whether the thread is alive. 1164 1165 This method returns True just before the run() method starts until just 1166 after the run() method terminates. See also the module function 1167 enumerate(). 1168 1169 """ 1170 assert self._initialized, "Thread.__init__() not called" 1171 if self._is_stopped or not self._started.is_set(): 1172 return False 1173 self._wait_for_tstate_lock(False) 1174 return not self._is_stopped 1175 1176 @property 1177 def daemon(self): 1178 """A boolean value indicating whether this thread is a daemon thread. 1179 1180 This must be set before start() is called, otherwise RuntimeError is 1181 raised. Its initial value is inherited from the creating thread; the 1182 main thread is not a daemon thread and therefore all threads created in 1183 the main thread default to daemon = False. 1184 1185 The entire Python program exits when only daemon threads are left. 1186 1187 """ 1188 assert self._initialized, "Thread.__init__() not called" 1189 return self._daemonic 1190 1191 @daemon.setter 1192 def daemon(self, daemonic): 1193 if not self._initialized: 1194 raise RuntimeError("Thread.__init__() not called") 1195 if self._started.is_set(): 1196 raise RuntimeError("cannot set daemon status of active thread") 1197 self._daemonic = daemonic 1198 1199 def isDaemon(self): 1200 """Return whether this thread is a daemon. 1201 1202 This method is deprecated, use the daemon attribute instead. 1203 1204 """ 1205 import warnings 1206 warnings.warn('isDaemon() is deprecated, get the daemon attribute instead', 1207 DeprecationWarning, stacklevel=2) 1208 return self.daemon 1209 1210 def setDaemon(self, daemonic): 1211 """Set whether this thread is a daemon. 1212 1213 This method is deprecated, use the .daemon property instead. 1214 1215 """ 1216 import warnings 1217 warnings.warn('setDaemon() is deprecated, set the daemon attribute instead', 1218 DeprecationWarning, stacklevel=2) 1219 self.daemon = daemonic 1220 1221 def getName(self): 1222 """Return a string used for identification purposes only. 1223 1224 This method is deprecated, use the name attribute instead. 1225 1226 """ 1227 import warnings 1228 warnings.warn('getName() is deprecated, get the name attribute instead', 1229 DeprecationWarning, stacklevel=2) 1230 return self.name 1231 1232 def setName(self, name): 1233 """Set the name string for this thread. 1234 1235 This method is deprecated, use the name attribute instead. 1236 1237 """ 1238 import warnings 1239 warnings.warn('setName() is deprecated, set the name attribute instead', 1240 DeprecationWarning, stacklevel=2) 1241 self.name = name 1242 1243 1244try: 1245 from _thread import (_excepthook as excepthook, 1246 _ExceptHookArgs as ExceptHookArgs) 1247except ImportError: 1248 # Simple Python implementation if _thread._excepthook() is not available 1249 from traceback import print_exception as _print_exception 1250 from collections import namedtuple 1251 1252 _ExceptHookArgs = namedtuple( 1253 'ExceptHookArgs', 1254 'exc_type exc_value exc_traceback thread') 1255 1256 def ExceptHookArgs(args): 1257 return _ExceptHookArgs(*args) 1258 1259 def excepthook(args, /): 1260 """ 1261 Handle uncaught Thread.run() exception. 1262 """ 1263 if args.exc_type == SystemExit: 1264 # silently ignore SystemExit 1265 return 1266 1267 if _sys is not None and _sys.stderr is not None: 1268 stderr = _sys.stderr 1269 elif args.thread is not None: 1270 stderr = args.thread._stderr 1271 if stderr is None: 1272 # do nothing if sys.stderr is None and sys.stderr was None 1273 # when the thread was created 1274 return 1275 else: 1276 # do nothing if sys.stderr is None and args.thread is None 1277 return 1278 1279 if args.thread is not None: 1280 name = args.thread.name 1281 else: 1282 name = get_ident() 1283 print(f"Exception in thread {name}:", 1284 file=stderr, flush=True) 1285 _print_exception(args.exc_type, args.exc_value, args.exc_traceback, 1286 file=stderr) 1287 stderr.flush() 1288 1289 1290# Original value of threading.excepthook 1291__excepthook__ = excepthook 1292 1293 1294def _make_invoke_excepthook(): 1295 # Create a local namespace to ensure that variables remain alive 1296 # when _invoke_excepthook() is called, even if it is called late during 1297 # Python shutdown. It is mostly needed for daemon threads. 1298 1299 old_excepthook = excepthook 1300 old_sys_excepthook = _sys.excepthook 1301 if old_excepthook is None: 1302 raise RuntimeError("threading.excepthook is None") 1303 if old_sys_excepthook is None: 1304 raise RuntimeError("sys.excepthook is None") 1305 1306 sys_exc_info = _sys.exc_info 1307 local_print = print 1308 local_sys = _sys 1309 1310 def invoke_excepthook(thread): 1311 global excepthook 1312 try: 1313 hook = excepthook 1314 if hook is None: 1315 hook = old_excepthook 1316 1317 args = ExceptHookArgs([*sys_exc_info(), thread]) 1318 1319 hook(args) 1320 except Exception as exc: 1321 exc.__suppress_context__ = True 1322 del exc 1323 1324 if local_sys is not None and local_sys.stderr is not None: 1325 stderr = local_sys.stderr 1326 else: 1327 stderr = thread._stderr 1328 1329 local_print("Exception in threading.excepthook:", 1330 file=stderr, flush=True) 1331 1332 if local_sys is not None and local_sys.excepthook is not None: 1333 sys_excepthook = local_sys.excepthook 1334 else: 1335 sys_excepthook = old_sys_excepthook 1336 1337 sys_excepthook(*sys_exc_info()) 1338 finally: 1339 # Break reference cycle (exception stored in a variable) 1340 args = None 1341 1342 return invoke_excepthook 1343 1344 1345# The timer class was contributed by Itamar Shtull-Trauring 1346 1347class Timer(Thread): 1348 """Call a function after a specified number of seconds: 1349 1350 t = Timer(30.0, f, args=None, kwargs=None) 1351 t.start() 1352 t.cancel() # stop the timer's action if it's still waiting 1353 1354 """ 1355 1356 def __init__(self, interval, function, args=None, kwargs=None): 1357 Thread.__init__(self) 1358 self.interval = interval 1359 self.function = function 1360 self.args = args if args is not None else [] 1361 self.kwargs = kwargs if kwargs is not None else {} 1362 self.finished = Event() 1363 1364 def cancel(self): 1365 """Stop the timer if it hasn't finished yet.""" 1366 self.finished.set() 1367 1368 def run(self): 1369 self.finished.wait(self.interval) 1370 if not self.finished.is_set(): 1371 self.function(*self.args, **self.kwargs) 1372 self.finished.set() 1373 1374 1375# Special thread class to represent the main thread 1376 1377class _MainThread(Thread): 1378 1379 def __init__(self): 1380 Thread.__init__(self, name="MainThread", daemon=False) 1381 self._set_tstate_lock() 1382 self._started.set() 1383 self._set_ident() 1384 if _HAVE_THREAD_NATIVE_ID: 1385 self._set_native_id() 1386 with _active_limbo_lock: 1387 _active[self._ident] = self 1388 1389 1390# Dummy thread class to represent threads not started here. 1391# These aren't garbage collected when they die, nor can they be waited for. 1392# If they invoke anything in threading.py that calls current_thread(), they 1393# leave an entry in the _active dict forever after. 1394# Their purpose is to return *something* from current_thread(). 1395# They are marked as daemon threads so we won't wait for them 1396# when we exit (conform previous semantics). 1397 1398class _DummyThread(Thread): 1399 1400 def __init__(self): 1401 Thread.__init__(self, name=_newname("Dummy-%d"), daemon=True) 1402 1403 self._started.set() 1404 self._set_ident() 1405 if _HAVE_THREAD_NATIVE_ID: 1406 self._set_native_id() 1407 with _active_limbo_lock: 1408 _active[self._ident] = self 1409 1410 def _stop(self): 1411 pass 1412 1413 def is_alive(self): 1414 assert not self._is_stopped and self._started.is_set() 1415 return True 1416 1417 def join(self, timeout=None): 1418 assert False, "cannot join a dummy thread" 1419 1420 1421# Global API functions 1422 1423def current_thread(): 1424 """Return the current Thread object, corresponding to the caller's thread of control. 1425 1426 If the caller's thread of control was not created through the threading 1427 module, a dummy thread object with limited functionality is returned. 1428 1429 """ 1430 try: 1431 return _active[get_ident()] 1432 except KeyError: 1433 return _DummyThread() 1434 1435def currentThread(): 1436 """Return the current Thread object, corresponding to the caller's thread of control. 1437 1438 This function is deprecated, use current_thread() instead. 1439 1440 """ 1441 import warnings 1442 warnings.warn('currentThread() is deprecated, use current_thread() instead', 1443 DeprecationWarning, stacklevel=2) 1444 return current_thread() 1445 1446def active_count(): 1447 """Return the number of Thread objects currently alive. 1448 1449 The returned count is equal to the length of the list returned by 1450 enumerate(). 1451 1452 """ 1453 with _active_limbo_lock: 1454 return len(_active) + len(_limbo) 1455 1456def activeCount(): 1457 """Return the number of Thread objects currently alive. 1458 1459 This function is deprecated, use active_count() instead. 1460 1461 """ 1462 import warnings 1463 warnings.warn('activeCount() is deprecated, use active_count() instead', 1464 DeprecationWarning, stacklevel=2) 1465 return active_count() 1466 1467def _enumerate(): 1468 # Same as enumerate(), but without the lock. Internal use only. 1469 return list(_active.values()) + list(_limbo.values()) 1470 1471def enumerate(): 1472 """Return a list of all Thread objects currently alive. 1473 1474 The list includes daemonic threads, dummy thread objects created by 1475 current_thread(), and the main thread. It excludes terminated threads and 1476 threads that have not yet been started. 1477 1478 """ 1479 with _active_limbo_lock: 1480 return list(_active.values()) + list(_limbo.values()) 1481 1482 1483_threading_atexits = [] 1484_SHUTTING_DOWN = False 1485 1486def _register_atexit(func, *arg, **kwargs): 1487 """CPython internal: register *func* to be called before joining threads. 1488 1489 The registered *func* is called with its arguments just before all 1490 non-daemon threads are joined in `_shutdown()`. It provides a similar 1491 purpose to `atexit.register()`, but its functions are called prior to 1492 threading shutdown instead of interpreter shutdown. 1493 1494 For similarity to atexit, the registered functions are called in reverse. 1495 """ 1496 if _SHUTTING_DOWN: 1497 raise RuntimeError("can't register atexit after shutdown") 1498 1499 call = functools.partial(func, *arg, **kwargs) 1500 _threading_atexits.append(call) 1501 1502 1503from _thread import stack_size 1504 1505# Create the main thread object, 1506# and make it available for the interpreter 1507# (Py_Main) as threading._shutdown. 1508 1509_main_thread = _MainThread() 1510 1511def _shutdown(): 1512 """ 1513 Wait until the Python thread state of all non-daemon threads get deleted. 1514 """ 1515 # Obscure: other threads may be waiting to join _main_thread. That's 1516 # dubious, but some code does it. We can't wait for C code to release 1517 # the main thread's tstate_lock - that won't happen until the interpreter 1518 # is nearly dead. So we release it here. Note that just calling _stop() 1519 # isn't enough: other threads may already be waiting on _tstate_lock. 1520 if _main_thread._is_stopped: 1521 # _shutdown() was already called 1522 return 1523 1524 global _SHUTTING_DOWN 1525 _SHUTTING_DOWN = True 1526 1527 # Call registered threading atexit functions before threads are joined. 1528 # Order is reversed, similar to atexit. 1529 for atexit_call in reversed(_threading_atexits): 1530 atexit_call() 1531 1532 # Main thread 1533 if _main_thread.ident == get_ident(): 1534 tlock = _main_thread._tstate_lock 1535 # The main thread isn't finished yet, so its thread state lock can't 1536 # have been released. 1537 assert tlock is not None 1538 assert tlock.locked() 1539 tlock.release() 1540 _main_thread._stop() 1541 else: 1542 # bpo-1596321: _shutdown() must be called in the main thread. 1543 # If the threading module was not imported by the main thread, 1544 # _main_thread is the thread which imported the threading module. 1545 # In this case, ignore _main_thread, similar behavior than for threads 1546 # spawned by C libraries or using _thread.start_new_thread(). 1547 pass 1548 1549 # Join all non-deamon threads 1550 while True: 1551 with _shutdown_locks_lock: 1552 locks = list(_shutdown_locks) 1553 _shutdown_locks.clear() 1554 1555 if not locks: 1556 break 1557 1558 for lock in locks: 1559 # mimic Thread.join() 1560 lock.acquire() 1561 lock.release() 1562 1563 # new threads can be spawned while we were waiting for the other 1564 # threads to complete 1565 1566 1567def main_thread(): 1568 """Return the main thread object. 1569 1570 In normal conditions, the main thread is the thread from which the 1571 Python interpreter was started. 1572 """ 1573 return _main_thread 1574 1575# get thread-local implementation, either from the thread 1576# module, or from the python fallback 1577 1578try: 1579 from _thread import _local as local 1580except ImportError: 1581 from _threading_local import local 1582 1583 1584def _after_fork(): 1585 """ 1586 Cleanup threading module state that should not exist after a fork. 1587 """ 1588 # Reset _active_limbo_lock, in case we forked while the lock was held 1589 # by another (non-forked) thread. http://bugs.python.org/issue874900 1590 global _active_limbo_lock, _main_thread 1591 global _shutdown_locks_lock, _shutdown_locks 1592 _active_limbo_lock = RLock() 1593 1594 # fork() only copied the current thread; clear references to others. 1595 new_active = {} 1596 1597 try: 1598 current = _active[get_ident()] 1599 except KeyError: 1600 # fork() was called in a thread which was not spawned 1601 # by threading.Thread. For example, a thread spawned 1602 # by thread.start_new_thread(). 1603 current = _MainThread() 1604 1605 _main_thread = current 1606 1607 # reset _shutdown() locks: threads re-register their _tstate_lock below 1608 _shutdown_locks_lock = _allocate_lock() 1609 _shutdown_locks = set() 1610 1611 with _active_limbo_lock: 1612 # Dangling thread instances must still have their locks reset, 1613 # because someone may join() them. 1614 threads = set(_enumerate()) 1615 threads.update(_dangling) 1616 for thread in threads: 1617 # Any lock/condition variable may be currently locked or in an 1618 # invalid state, so we reinitialize them. 1619 if thread is current: 1620 # There is only one active thread. We reset the ident to 1621 # its new value since it can have changed. 1622 thread._reset_internal_locks(True) 1623 ident = get_ident() 1624 thread._ident = ident 1625 new_active[ident] = thread 1626 else: 1627 # All the others are already stopped. 1628 thread._reset_internal_locks(False) 1629 thread._stop() 1630 1631 _limbo.clear() 1632 _active.clear() 1633 _active.update(new_active) 1634 assert len(_active) == 1 1635 1636 1637if hasattr(_os, "register_at_fork"): 1638 _os.register_at_fork(after_in_child=_after_fork) 1639