549 lines
64 KiB
Plaintext
549 lines
64 KiB
Plaintext
|
Ë
|
|||
|
|
*åf…ñ ã óÂ — d Z ddlZddlZddlZddlZddlmZ ddl
|
|||
|
|
m Z ddl m
|
|||
|
|
Z ddlmZ g d¢Zej* Zej. Zej2 Zej6 Zej8 Z ej: Z ej> Z d Z ejC d
|
|||
|
|
« ejD Z# ejH Z%ejL Z&[da'da(d „ Z)d
|
|||
|
|
„ Z*d„ Z+d„ Z,d„ Z-d„ Z.eZ/d„ Z$ G d„ d« Z0e0Z1 G d„ d« Z2 G d„ d« Z3 G d„ de3« Z4 G d„ d « Z5 G d „ d « Z6 G d „ d e7« Z8 ed!« jr Z:d"„ Z; e$« a<i Z=i Z> e « Z? e« a@ eA« aBd#„ ZC G d$„ d%« ZD dd&lmEaFmGZH tŒ ZMd-„ ZN G d.„ d/eD« ZO G d0„ d1eD« ZP G d2„ d3eD« ZQd4„ ZRd5„ ZSd6„ ZTd7„ ZUd8„ ZVd9„ ZWg ZXd aYd:„ ZZdd;lm[Z[ eP« a\d<„ Z]d=„ Z^ dd>lm_Z` d@„ Zb ecedA« r ejÈ eb¬B« yy# e$ r
|
|||
|
|
ddlmZ Y �ŒÏw xY w# e $ r d„ Z Y �Œ‘w xY w# e $ r d Z Y �Œw xY w# e $ r dZ%Y �Œtw xY w# e$ r dd'lImJZK dd(lmLZL eLd)d*« ZGd+„ ZHd,„ aFY ŒÝw xY w# e$ r dd?lam`Z` Y Œ‘w xY w)Cz;Thread module emulating a subset of Java's threading model.é N)Ú monotonic)ÚWeakSet)Úcount)Údeque)Ú get_identÚ active_countÚ ConditionÚcurrent_threadÚ enumerateÚ main_threadÚ TIMEOUT_MAXÚEventÚLockÚRLockÚ SemaphoreÚBoundedSemaphoreÚThreadÚBarrierÚBrokenBarrierErrorÚTimerÚ ThreadErrorÚ
|
|||
|
|
setprofileÚsettraceÚlocalÚ
|
|||
|
|
stack_sizeÚ
|
|||
|
|
excepthookÚExceptHookArgsÚgettraceÚ
|
|||
|
|
getprofileÚsetprofile_all_threadsÚsettrace_all_threadsc ó — y©NT© r$ ó úEC:\Users\RCi\AppData\Local\Programs\Python\Python312\Lib\threading.pyÚ_is_main_interpreterr' 4 s € Ør% TÚ
|
|||
|
|
get_native_idFc ó — | a y)z·Set a profile function for all threads started from the threading module.
|
|||
|
|
|
|||
|
|
The func will be passed to sys.setprofile() for each thread, before its
|
|||
|
|
run() method is called.
|
|||
|
|
N©Ú
|
|||
|
|
_profile_hook©Úfuncs r& r r J s € ð �Mr% c óD — t | « t j | « y)zïSet a profile function for all threads started from the threading module
|
|||
|
|
and all Python threads that are currently executing.
|
|||
|
|
|
|||
|
|
The func will be passed to sys.setprofile() for each thread, before its
|
|||
|
|
run() method is called.
|
|||
|
|
N)r Ú_sysÚ_setprofileallthreadsr, s r& r r S s € ô ˆtÔÜ× Ñ ˜tÕ$r% c ó — t S )z;Get the profiler function as set by threading.setprofile().r* r$ r% r& r r ] s € ä Ðr% c ó — | a y)z³Set a trace function for all threads started from the threading module.
|
|||
|
|
|
|||
|
|
The func will be passed to sys.settrace() for each thread, before its run()
|
|||
|
|
method is called.
|
|||
|
|
N©Ú _trace_hookr, s r& r r a s € ð �Kr% c óD — t | « t j | « y)zëSet a trace function for all threads started from the threading module
|
|||
|
|
and all Python threads that are currently executing.
|
|||
|
|
|
|||
|
|
The func will be passed to sys.settrace() for each thread, before its run()
|
|||
|
|
method is called.
|
|||
|
|
N)r r/ Ú_settraceallthreadsr, s r& r! r! j s € ô
|
|||
|
|
ˆT„NÜ× Ñ ˜TÕ"r% c ó — t S )z6Get the trace function as set by threading.settrace().r3 r$ r% r& r r t s € ä Ðr% c ó: — t € t | i |¤ŽS t | i |¤ŽS )a2 Factory function that returns a new reentrant lock.
|
|||
|
|
|
|||
|
|
A reentrant lock must be released by the thread that acquired it. Once a
|
|||
|
|
thread has acquired a reentrant lock, the same thread may acquire it again
|
|||
|
|
without blocking; the thread must release it once for each time it has
|
|||
|
|
acquired it.
|
|||
|
|
|
|||
|
|
)Ú_CRLockÚ_PyRLock)ÚargsÚkwargss r& r r | s) € ô €Ü˜Ð( Ñ(Ð(Ü �DÐ #˜FÑ #Ð#r% c óR — e Zd ZdZd„ Zd„ Zd„ Zd
|
|||
|
|
d„ZeZd„ Z d„ Z
|
|||
|
|
d„ Z d „ Z d
|
|||
|
|
„ Z
|
|||
|
|
d „ Zy )Ú_RLocka, This class implements reentrant lock objects.
|
|||
|
|
|
|||
|
|
A reentrant lock must be released by the thread that acquired it. Once a
|
|||
|
|
thread has acquired a reentrant lock, the same thread may acquire it
|
|||
|
|
again without blocking; the thread must release it once for each time it
|
|||
|
|
has acquired it.
|
|||
|
|
|
|||
|
|
c ó> — t « | _ d | _ d| _ y ©Nr )Ú_allocate_lockÚ_blockÚ_ownerÚ_count©Úselfs r& Ú__init__z_RLock.__init__“ s € Ü$Ó&ˆŒ ؈Œ ؈� r% c ó6 — | j } t | j }d| j j « rdnd| j j | j j || j t t | « « fz S # t $ r Y Œvw xY w)Nz)<%s %s.%s object owner=%r count=%d at %s>ÚlockedÚunlocked) rC Ú_activeÚnameÚKeyErrorrB rI Ú __class__Ú
|
|||
|
|
__module__Ú __qualname__rD ÚhexÚid)rF Úowners r& Ú__repr__z_RLock.__repr__˜ sŠ € Ø— ‘ ˆð ܘE‘N×'Ñ'ˆEð ;Ø Ÿ ™ ×*Ñ*Ô,‰H°*Ø �N‰N× %Ñ %Ø �N‰N× 'Ñ 'Ø Ø �K‰KÜ ”�4“‹Mð
|
|||
|
|
>
|
|||
|
|
ñ
|
|||
|
|
ð
|
|||
|
|
øô ò Ù ð ús ŽB  BÂBc óT — | j j « d | _ d| _ y r@ )rB Ú_at_fork_reinitrC rD rE s r& rV z_RLock._at_fork_reinit§ s € Ø � ‰ ×#Ñ#Ô%؈Œ ؈� r% c ó¼ — t « }| j |k( r| xj dz
|
|||
|
|
c_ y| j j ||« }|r|| _ d| _ |S )a Acquire a lock, blocking or non-blocking.
|
|||
|
|
|
|||
|
|
When invoked without arguments: if this thread already owns the lock,
|
|||
|
|
increment the recursion level by one, and return immediately. Otherwise,
|
|||
|
|
if another thread owns the lock, block until the lock is unlocked. Once
|
|||
|
|
the lock is unlocked (not owned by any thread), then grab ownership, set
|
|||
|
|
the recursion level to one, and return. If more than one thread is
|
|||
|
|
blocked waiting until the lock is unlocked, only one at a time will be
|
|||
|
|
able to grab ownership of the lock. There is no return value in this
|
|||
|
|
case.
|
|||
|
|
|
|||
|
|
When invoked with the blocking argument set to true, do the same thing
|
|||
|
|
as when called without arguments, and return true.
|
|||
|
|
|
|||
|
|
When invoked with the blocking argument set to false, do not block. If a
|
|||
|
|
call without an argument would block, return false immediately;
|
|||
|
|
otherwise, do the same thing as when called without arguments, and
|
|||
|
|
return true.
|
|||
|
|
|
|||
|
|
When invoked with the floating-point timeout argument set to a positive
|
|||
|
|
value, block for at most the number of seconds specified by timeout
|
|||
|
|
and as long as the lock cannot be acquired. Return true if the lock has
|
|||
|
|
been acquired, false if the timeout has elapsed.
|
|||
|
|
|
|||
|
|
é )r rC rD rB Úacquire)rF ÚblockingÚtimeoutÚmeÚrcs r& rY z_RLock.acquire¬ sT € ô4 ‹[ˆØ �;‰;˜"Ò Ø �KŠK˜1Ñ �KØØ
|
|||
|
|
�[‰[×
|
|||
|
|
Ñ
|
|||
|
|
¨7Ó
|
|||
|
|
3ˆÙ
|
|||
|
|
Ø ˆDŒK؈DŒK؈ r% c ó¼ — | j t « k7 r t d« ‚| j dz
|
|||
|
|
x| _ }|s"d| _ | j j « yy)am Release a lock, decrementing the recursion level.
|
|||
|
|
|
|||
|
|
If after the decrement it is zero, reset the lock to unlocked (not owned
|
|||
|
|
by any thread), and if any other threads are blocked waiting for the
|
|||
|
|
lock to become unlocked, allow exactly one of them to proceed. If after
|
|||
|
|
the decrement the recursion level is still nonzero, the lock remains
|
|||
|
|
locked and owned by the calling thread.
|
|||
|
|
|
|||
|
|
Only call this method when the calling thread owns the lock. A
|
|||
|
|
RuntimeError is raised if this method is called when the lock is
|
|||
|
|
unlocked.
|
|||
|
|
|
|||
|
|
There is no return value.
|
|||
|
|
|
|||
|
|
ú cannot release un-acquired lockrX N)rC r Ú RuntimeErrorrD rB Úrelease)rF r s r& ra z_RLock.releaseÒ sQ € ð �;‰;œ)›+Ò %Ü Ð @ÓAÐ AØ "Ÿk™k¨A™oÐ-ˆŒ �eÙØ ˆDŒKØ �K‰K× Ñ Õ !ð r% c ó$ — | j « y ©N©ra ©rF ÚtÚvÚtbs r& Ú__exit__z_RLock.__exit__é ó € Ø � ‰ �r% c óV — | j j « |\ | _ | _ y rc )rB rY rD rC )rF Ústates r& Ú_acquire_restorez_RLock._acquire_restoreî s € Ø � ‰ ×ÑÔ Ø#(Ñ ˆŒ �T•[r% c ó¾ — | j dk( r t d« ‚| j }d| _ | j }d | _ | j j « ||fS )Nr r_ )rD r` rC rB ra )rF r rS s r& Ú
|
|||
|
|
_release_savez_RLock._release_saveò sT € Ø �;‰;˜!Ò Ü Ð @ÓAÐ AØ— ‘ ˆØˆŒ Ø— ‘ ˆØˆŒ Ø � ‰ ×ÑÔ Ø�uˆ~Ð r% c ó0 — | j t « k( S rc )rC r rE s r& Ú _is_ownedz_RLock._is_ownedü s € Ø�{‰{œi›kÑ)Ð)r% c óJ — | j t « k7 ry| j S r@ )rC r rD rE s r& Ú_recursion_countz_RLock._recursion_count s € Ø �;‰;œ)›+Ò %ØØ�{‰{Ðr% N©Téÿÿÿÿ)Ú__name__rO rP Ú__doc__rG rT rV rY Ú __enter__ra ri rm ro rq rs r$ r% r& r> r> ‰ sA „ ñòò
|
|||
|
|
|
|||
|
|
|
|||
|
|
ò ó
|
|||
|
|
"ðH €Iò"ò.ò
|
|||
|
|
)ò ò*ó
|
|||
|
|
r% r> c óf — e Zd ZdZdd„Zd„ Zd„ Zd„ Zd„ Zd„ Z d „ Z
|
|||
|
|
d
|
|||
|
|
„ Z dd „Z dd „Z
|
|||
|
|
dd
|
|||
|
|
„Zd„ Zd„ Zy)r aj Class that implements a condition variable.
|
|||
|
|
|
|||
|
|
A condition variable allows one or more threads to wait until they are
|
|||
|
|
notified by another thread.
|
|||
|
|
|
|||
|
|
If the lock argument is given and not None, it must be a Lock or RLock
|
|||
|
|
object, and it is used as the underlying lock. Otherwise, a new RLock object
|
|||
|
|
is created and used as the underlying lock.
|
|||
|
|
|
|||
|
|
Nc ó: — |€
|
|||
|
|
t « }|| _ |j | _ |j | _ t |d« r|j
|
|||
|
|
| _ t |d« r|j | _ t |d« r|j | _ t « | _ y )Nro rm rq )
|
|||
|
|
r Ú_lockrY ra Úhasattrro rm rq Ú_dequeÚ_waiters©rF Úlocks r& rG zCondition.__init__ s| € Ø ˆ<Ü“7ˆD؈Œ
|
|||
|
|
à—|‘|ˆŒ Ø—|‘|ˆŒ ô �4˜ Ô )Ø!%×!3Ñ!3ˆDÔ Ü �4Ð+Ô ,Ø$(×$9Ñ$9ˆDÔ !Ü �4˜Ô %Ø !Ÿ^™^ˆDŒNÜ ›ˆ�
|
|||
|
|
r% c ól — | j j « | j j « y rc )r{ rV r~ ÚclearrE s r& rV zCondition._at_fork_reinit' s" € Ø �
|
|||
|
|
‰
|
|||
|
|
×"Ñ"Ô$Ø �
|
|||
|
|
‰
|
|||
|
|
×ÑÕ r% c ó6 — | j j « S rc )r{ rx rE s r& rx zCondition.__enter__+ s € Ø�z‰z×#Ñ#Ó%Ð%r% c ó4 — | j j |Ž S rc )r{ ri )rF r; s r& ri zCondition.__exit__. s € Ø"ˆt�z‰z×"Ñ" DÐ)Ð)r% c óJ — d| j t | j « fz S )Nz<Condition(%s, %d)>)r{ Úlenr~ rE s r& rT zCondition.__repr__1 s € Ø$¨¯
|
|||
|
|
©
|
|||
|
|
´C¸¿
|
|||
|
|
¹
|
|||
|
|
Ó4FÐ'GÑGÐGr% c ó8 — | j j « y rc )r{ ra rE s r& ro zCondition._release_save4 ó € Ø �
|
|||
|
|
‰
|
|||
|
|
×ÑÕ r% c ó8 — | j j « y rc )r{ rY )rF Úxs r& rm zCondition._acquire_restore7 rˆ r% c óp — | j j d« r| j j « yy)NFT)r{ rY ra rE s r& rq zCondition._is_owned: s, € ð �:‰:× Ñ ˜eÔ $Ø �J‰J× Ñ Ô Øàr% c óN — | j « s t d« ‚t « }|j « | j j |« | j
|
|||
|
|
« }d} |€|j « d}n)|dkD r|j d|« }n|j d« }|| j |« |s | j j |« S S # t $ r Y S w xY w# | j |« |s, | j j |« w # t $ r Y w w xY ww xY w)ak Wait until notified or until a timeout occurs.
|
|||
|
|
|
|||
|
|
If the calling thread has not acquired the lock when this method is
|
|||
|
|
called, a RuntimeError is raised.
|
|||
|
|
|
|||
|
|
This method releases the underlying lock, and then blocks until it is
|
|||
|
|
awakened by a notify() or notify_all() call for the same condition
|
|||
|
|
variable in another thread, or until the optional timeout occurs. Once
|
|||
|
|
awakened or timed out, it re-acquires the lock and returns.
|
|||
|
|
|
|||
|
|
When the timeout argument is present and not None, it should be a
|
|||
|
|
floating point number specifying a timeout for the operation in seconds
|
|||
|
|
(or fractions thereof).
|
|||
|
|
|
|||
|
|
When the underlying lock is an RLock, it is not released using its
|
|||
|
|
release() method, since this may not actually unlock the lock when it
|
|||
|
|
was acquired multiple times recursively. Instead, an internal interface
|
|||
|
|
of the RLock class is used, which really unlocks it even when it has
|
|||
|
|
been recursively acquired several times. Another internal interface is
|
|||
|
|
then used to restore the recursion level when the lock is reacquired.
|
|||
|
|
|
|||
|
|
z cannot wait on un-acquired lockFTr )
|
|||
|
|
rq r` rA rY r~ Úappendro rm ÚremoveÚ
|
|||
|
|
ValueError)rF r[ ÚwaiterÚ saved_stateÚgotits r& ÚwaitzCondition.waitC s € ð. �~‰~Ô Ü Ð @ÓAÐ AÜ Ó!ˆØ�‰ÔØ �
|
|||
|
|
‰
|
|||
|
|
× Ñ ˜VÔ$Ø×(Ñ(Ó*ˆ ؈ð ؈ؗ‘Ô Ø ‘à˜Q’;Ø "ŸN™N¨4°Ó 9‘Eà "ŸN™N¨5Ó 1�EØà × !Ñ ! +Ô .ÙðØ—M‘M×(Ñ(¨Õ0ð øô "ò Ùðûð
|
|||
|
|
× !Ñ ! +Ô .ÙðØ—M‘M×(Ñ(¨Õ0øÜ!ò Ùðúð úsB Á$?C# Â7Cà C à C Ã#D$Ã8DÄD$Ä D Ä D$Ä D Ä D$c ó¤ — d}|} |« }|sB|�%|€t « |z }n|t « z
|
|||
|
|
}|dk r |S | j |« |« }|sŒB|S )zÜWait until a condition evaluates to True.
|
|||
|
|
|
|||
|
|
predicate should be a callable which result will be interpreted as a
|
|||
|
|
boolean value. A timeout may be provided giving the maximum time to
|
|||
|
|
wait.
|
|||
|
|
|
|||
|
|
Nr )Ú_timer“ )rF Ú predicater[ ÚendtimeÚwaittimeÚresults r& Úwait_forzCondition.wait_fors sm € ð ˆØˆÙ“ˆÙØÐ#Ø�?Ü #›g¨Ñ 0‘Gà &¬«Ñ 0�HØ 1’}Ø ð ˆ
|
|||
|
|
ð
|
|||
|
|
�I‰I�hÔ Ù “[ˆFò ð ˆ
|
|||
|
|
r% c ó — | j « s t d« ‚| j }|r=|dkD r7|d } |j « |dz } |j |« |r|dkD rŒ5yyyy# t $ r Y Œ)w xY w# t
|
|||
|
|
$ r Y Œ&w xY w)aK Wake up one or more threads waiting on this condition, if any.
|
|||
|
|
|
|||
|
|
If the calling thread has not acquired the lock when this method is
|
|||
|
|
called, a RuntimeError is raised.
|
|||
|
|
|
|||
|
|
This method wakes up at most n of the threads waiting for the condition
|
|||
|
|
variable; it is a no-op if no threads are waiting.
|
|||
|
|
|
|||
|
|
z!cannot notify on un-acquired lockr rX N)rq r` r~ ra rŽ r� )rF ÚnÚwaitersr� s r& ÚnotifyzCondition.notifyŠ sš € ð �~‰~Ô Ü Ð BÓCÐ CØ—-‘-ˆÙ˜!˜aš%Ø ˜Q‘ZˆFð
|
|||
|
|
Ø—‘Ô ð �Q‘�ð
|
|||
|
|
Ø—‘˜vÔ&ñ ˜!˜aœ%ˆg˜%ˆgøô ò
|
|||
|
|
ñ
|
|||
|
|
ð
|
|||
|
|
ûô ò
|
|||
|
|
Ùð
|
|||
|
|
ús# µA( Á A7 Á( A4Á3A4Á7 BÂBc óL — | j t | j « « y)z¯Wake up all threads waiting on this condition.
|
|||
|
|
|
|||
|
|
If the calling thread has not acquired the lock when this method
|
|||
|
|
is called, a RuntimeError is raised.
|
|||
|
|
|
|||
|
|
N)rž r† r~ rE s r& Ú
|
|||
|
|
notify_allzCondition.notify_all¨ s € ð
|
|||
|
|
� ‰ ”C˜Ÿ
|
|||
|
|
™
|
|||
|
|
Ó&Õ'r% c ó\ — ddl }|j dt d¬« | j « y)zvWake up all threads waiting on this condition.
|
|||
|
|
|
|||
|
|
This method is deprecated, use notify_all() instead.
|
|||
|
|
|
|||
|
|
r Nz3notifyAll() is deprecated, use notify_all() insteadé ©Ú
|
|||
|
|
stacklevel)ÚwarningsÚwarnÚDeprecationWarningr ©rF r¥ s r& Ú notifyAllzCondition.notifyAll± s* € ó Ø�
|
|||
|
|
‰
|
|||
|
|
ÐKÜ(°Qð ô 8à �‰Õr% rc ©rX )rv rO rP rw rG rV rx ri rT ro rm rq r“ rš rž r r© r$ r% r& r r sJ „ ñ ó!ò$ ò&ò*òHò ò òó.ó`ó. ò<(ó r% r c ó8 — e Zd ZdZdd„Zd„ Zd d„ZeZdd„Zd„ Z y)
|
|||
|
|
r aG This class implements semaphore objects.
|
|||
|
|
|
|||
|
|
Semaphores manage a counter representing the number of release() calls minus
|
|||
|
|
the number of acquire() calls, plus an initial value. The acquire() method
|
|||
|
|
blocks if necessary until it can return without making the counter
|
|||
|
|
negative. If not given, value defaults to 1.
|
|||
|
|
|
|||
|
|
c ób — |dk r t d« ‚t t « « | _ || _ y )Nr z$semaphore initial value must be >= 0)r� r r Ú_condÚ_value)rF Úvalues r& rG zSemaphore.__init__É s* € Ø �1Š9Ü Ð CÓDÐ DÜ œt›vÓ&ˆŒ
|
|||
|
|
؈� r% c óˆ — | j }d|j › d|j › dt | « d›d| j › d� S )Nú<ú.ú at ú#xú: value=ú>)rN rO rP rR r® ©rF Úclss r& rT zSemaphore.__repr__Ï sK € Ø�n‰nˆØ�C—N‘NÐ# 1 S×%5Ñ%5Ð$6°d¼2¸d»8ÀB¸-ð HØ Ÿ+™+˜ að)ð *r% Nc ób — |s
|
|||
|
|
|� t d« ‚d}d}| j 5 | j dk( rS|sng|�#|€t « |z }n|t « z
|
|||
|
|
}|dk rnB| j j |« | j dk( rŒS| xj dz c_ d}ddd« |S # 1 sw Y |S xY w)aÔ Acquire a semaphore, decrementing the internal counter by one.
|
|||
|
|
|
|||
|
|
When invoked without arguments: if the internal counter is larger than
|
|||
|
|
zero on entry, decrement it by one and return immediately. If it is zero
|
|||
|
|
on entry, block, waiting until some other thread has called release() to
|
|||
|
|
make it larger than zero. This is done with proper interlocking so that
|
|||
|
|
if multiple acquire() calls are blocked, release() will wake exactly one
|
|||
|
|
of them up. The implementation may pick one at random, so the order in
|
|||
|
|
which blocked threads are awakened should not be relied on. There is no
|
|||
|
|
return value in this case.
|
|||
|
|
|
|||
|
|
When invoked with blocking set to true, do the same thing as when called
|
|||
|
|
without arguments, and return true.
|
|||
|
|
|
|||
|
|
When invoked with blocking set to false, do not block. If a call without
|
|||
|
|
an argument would block, return false immediately; otherwise, do the
|
|||
|
|
same thing as when called without arguments, and return true.
|
|||
|
|
|
|||
|
|
When invoked with a timeout other than None, it will block for at
|
|||
|
|
most timeout seconds. If acquire does not complete successfully in
|
|||
|
|
that interval, return false. Return true otherwise.
|
|||
|
|
|
|||
|
|
Nz.can't specify timeout for non-blocking acquireFr rX T)r� r r® r• r“ )rF rZ r[ r] r— s r& rY zSemaphore.acquireÔ s¹ € ñ0 ˜GÐ /Ü Ð MÓNÐ NØ
|
|||
|
|
ˆØˆØ
|
|||
|
|
�Z‰Zñ Ø—+‘+ Ò"Ù ØØÐ&Ø �Ü"'£'¨GÑ"3™à")¬E«GÑ"3˜Ø" aš<Ø !Ø—
|
|||
|
|
‘
|
|||
|
|
—‘ Ô(ð —+‘+ Ó"ð — ’ ˜qÑ • Ø�÷ ð ˆ ÷ ð ˆ ús A"B$ÂB$Â$B.c óÆ — |dk r t d« ‚| j 5 | xj |z
|
|||
|
|
c_ | j j |« ddd« y# 1 sw Y yxY w)zßRelease a semaphore, incrementing the internal counter by one or more.
|
|||
|
|
|
|||
|
|
When the counter is zero on entry and another thread is waiting for it
|
|||
|
|
to become larger than zero again, wake up that thread.
|
|||
|
|
|
|||
|
|
rX ún must be one or moreN)r� r r® rž ©rF rœ s r& ra zSemaphore.release sS € ð
|
|||
|
|
ˆqŠ5Ü Ð 4Ó5Ð 5Ø
|
|||
|
|
�Z‰Zñ !Ø �KŠK˜1Ñ �KØ �J‰J× Ñ ˜aÔ ÷ !÷ !ñ !ús �1AÁA c ó$ — | j « y rc rd re s r& ri zSemaphore.__exit__ rj r% rª )TN)
|
|||
|
|
rv rO rP rw rG rT rY rx ra ri r$ r% r& r r ½ s( „ ñó ò *ó
|
|||
|
|
+ðZ €Ió !ór% r c ó2 ‡ — e Zd ZdZdˆ fd„ Zd„ Zdd„Zˆ xZS )r a© Implements a bounded semaphore.
|
|||
|
|
|
|||
|
|
A bounded semaphore checks to make sure its current value doesn't exceed its
|
|||
|
|
initial value. If it does, ValueError is raised. In most situations
|
|||
|
|
semaphores are used to guard resources with limited capacity.
|
|||
|
|
|
|||
|
|
If the semaphore is released too many times it's a sign of a bug. If not
|
|||
|
|
given, value defaults to 1.
|
|||
|
|
|
|||
|
|
Like regular semaphores, bounded semaphores manage a counter representing
|
|||
|
|
the number of release() calls minus the number of acquire() calls, plus an
|
|||
|
|
initial value. The acquire() method blocks if necessary until it can return
|
|||
|
|
without making the counter negative. If not given, value defaults to 1.
|
|||
|
|
|
|||
|
|
c ó2 •— t ‰| � |« || _ y rc )ÚsuperrG Ú_initial_value)rF r¯ rN s €r& rG zBoundedSemaphore.__init__% s ø€ Ü
|
|||
|
|
‰Ñ˜Ô Ø #ˆÕr% c ó¢ — | j }d|j › d|j › dt | « d›d| j › d| j
|
|||
|
|
› d� S )Nr± r² r³ r´ rµ ú/r¶ )rN rO rP rR r® rÁ r· s r& rT zBoundedSemaphore.__repr__) sY € Ø�n‰nˆØ�C—N‘NÐ# 1 S×%5Ñ%5Ð$6°d¼2¸d»8ÀB¸-ð HØ Ÿ+™+˜ a¨×(;Ñ(;Ð'<¸Að?ð @r% c ó — |dk r t d« ‚| j 5 | j |z | j kD r t d« ‚| xj |z
|
|||
|
|
c_ | j j |« ddd« y# 1 sw Y yxY w)a> Release a semaphore, incrementing the internal counter by one or more.
|
|||
|
|
|
|||
|
|
When the counter is zero on entry and another thread is waiting for it
|
|||
|
|
to become larger than zero again, wake up that thread.
|
|||
|
|
|
|||
|
|
If the number of releases exceeds the number of acquires,
|
|||
|
|
raise a ValueError.
|
|||
|
|
|
|||
|
|
rX r» z!Semaphore released too many timesN)r� r r® rÁ rž r¼ s r& ra zBoundedSemaphore.release. su € ð
|
|||
|
|
ˆqŠ5Ü Ð 4Ó5Ð 5Ø
|
|||
|
|
�Z‰Zñ !Ø�{‰{˜Q‰ ×!4Ñ!4Ò4Ü Ð!DÓEÐEØ �KŠK˜1Ñ �KØ �J‰J× Ñ ˜aÔ ÷ !÷ !ñ !ús �AA>Á>Brª )rv rO rP rw rG rT ra Ú
|
|||
|
|
__classcell__)rN s @r& r r s ø„ ñõ $ò@÷
|
|||
|
|
!r% r c óB — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z
|
|||
|
|
d d
|
|||
|
|
„Z y ) r zòClass implementing event objects.
|
|||
|
|
|
|||
|
|
Events manage a flag that can be set to true with the set() method and reset
|
|||
|
|
to false with the clear() method. The wait() method blocks until the flag is
|
|||
|
|
true. The flag is initially false.
|
|||
|
|
|
|||
|
|
c óB — t t « « | _ d| _ y )NF)r r r Ú_flagrE s r& rG zEvent.__init__L s € Ü œt›vÓ&ˆŒ
|
|||
|
|
؈�
|
|||
|
|
r% c ó” — | j }| j rdnd}d|j › d|j › dt | « d›d|› d� S ) NÚsetÚunsetr± r² r³ r´ z: r¶ )rN rÈ rO rP rR )rF r¸ Ústatuss r& rT zEvent.__repr__P sL € Ø�n‰nˆØ Ÿ*š*‘¨'ˆØ�3—>‘>Ð" ! C×$4Ñ$4Ð#5°T¼"¸T»(À2¸ ÀbÈÈÐPQÐRÐRr% c ó8 — | j j « y rc )r rV rE s r& rV zEvent._at_fork_reinitU s € à �
|
|||
|
|
‰
|
|||
|
|
×"Ñ"Õ$r% c ó — | j S )z5Return true if and only if the internal flag is true.)rÈ rE s r& Úis_setz Event.is_setY s € à�z‰zÐr% c óZ — ddl }|j dt d¬« | j « S )zyReturn true if and only if the internal flag is true.
|
|||
|
|
|
|||
|
|
This method is deprecated, use is_set() instead.
|
|||
|
|
|
|||
|
|
r Nz+isSet() is deprecated, use is_set() insteadr¢ r£ )r¥ r¦ r§ rÏ r¨ s r& ÚisSetz Event.isSet] s, € ó Ø�
|
|||
|
|
‰
|
|||
|
|
ÐCÜ(°Qð ô 8à�{‰{‹}Ð r% c óˆ — | j 5 d| _ | j j « ddd« y# 1 sw Y yxY w)z·Set the internal flag to true.
|
|||
|
|
|
|||
|
|
All threads waiting for it to become true are awakened. Threads
|
|||
|
|
that call wait() once the flag is true will not block at all.
|
|||
|
|
|
|||
|
|
TN)r rÈ r rE s r& rÊ z Event.seth s7 € ð �Z‰Zñ $Ø ˆDŒJØ �J‰J× !Ñ !Ô #÷ $÷ $ñ $ús �"8¸Ac óT — | j 5 d| _ ddd« y# 1 sw Y yxY w)zªReset the internal flag to false.
|
|||
|
|
|
|||
|
|
Subsequently, threads calling wait() will block until set() is called to
|
|||
|
|
set the internal flag to true again.
|
|||
|
|
|
|||
|
|
FN)r rÈ rE s r& r‚ z Event.clears s' € ð �Z‰Zñ Ø ˆDŒJ÷ ÷ ñ ús � ž'Nc óœ — | j 5 | j }|s| j j |« }|cddd« S # 1 sw Y yxY w)aH Block until the internal flag is true.
|
|||
|
|
|
|||
|
|
If the internal flag is true on entry, return immediately. Otherwise,
|
|||
|
|
block until another thread calls set() to set the flag to true, or until
|
|||
|
|
the optional timeout occurs.
|
|||
|
|
|
|||
|
|
When the timeout argument is present and not None, it should be a
|
|||
|
|
floating point number specifying a timeout for the operation in seconds
|
|||
|
|
(or fractions thereof).
|
|||
|
|
|
|||
|
|
This method returns the internal flag on exit, so it will always return
|
|||
|
|
True except if a timeout is given and the operation times out.
|
|||
|
|
|
|||
|
|
N)r rÈ r“ )rF r[ Úsignaleds r& r“ z
|
|||
|
|
Event.wait} sA € ð �Z‰Zñ Ø—z‘zˆHÙØ Ÿ:™:Ÿ?™?¨7Ó3�Ø÷ ÷ ò ús �+AÁA rc ) rv rO rP rw rG rT rV rÏ rÑ rÊ r‚ r“ r$ r% r& r r A s0 „ ñòòSò
|
|||
|
|
%òò ò $ò ô r% r c ó€ — e Zd ZdZdd„Zd„ Zdd„Zd„ Zd„ Zd„ Z d „ Z
|
|||
|
|
d
|
|||
|
|
„ Z d „ Z d „ Z
|
|||
|
|
ed
|
|||
|
|
„ « Zed„ « Zed„ « Zy)r zØImplements a Barrier.
|
|||
|
|
|
|||
|
|
Useful for synchronizing a fixed number of threads at known synchronization
|
|||
|
|
points. Threads block on 'wait()' and are simultaneously awoken once they
|
|||
|
|
have all made that call.
|
|||
|
|
|
|||
|
|
Nc óz — t t « « | _ || _ || _ || _ d| _ d| _ y)aW Create a barrier, initialised to 'parties' threads.
|
|||
|
|
|
|||
|
|
'action' is a callable which, when supplied, will be called by one of
|
|||
|
|
the threads after they have all entered the barrier and just prior to
|
|||
|
|
releasing them all. If a 'timeout' is provided, it is used as the
|
|||
|
|
default for all subsequent 'wait()' calls.
|
|||
|
|
|
|||
|
|
r N)r r r Ú_actionÚ_timeoutÚ_partiesÚ_staterD )rF ÚpartiesÚactionr[ s r& rG zBarrier.__init__§ s5 € ô œt›vÓ&ˆŒ
|
|||
|
|
Ø ˆŒ Ø ˆŒ
|
|||
|
|
Ø ˆŒ
|
|||
|
|
؈Œ ؈� r% c ó — | j }| j r*d|j › d|j › dt | « d›d�S d|j › d|j › dt | « d›d| j
|
|||
|
|
› d| j › d� S ) Nr± r² r³ r´ z : broken>z
|
|||
|
|
: waiters=rà r¶ )rN ÚbrokenrO rP rR Ú n_waitingrÜ r· s r& rT zBarrier.__repr__· sŠ € Ø�n‰nˆØ �;Š;Ø�s—~‘~Ð& a¨×(8Ñ(8Ð'9¸¼bÀ»hÀr¸]È)ÐTÐ TØ�C—N‘NÐ# 1 S×%5Ñ%5Ð$6°d¼2¸d»8ÀB¸-ð H Ø ŸN™NÐ+¨1¨T¯\©\¨N¸!ð=ð >r% c óÐ — |€ | j }| j 5 | j « | j }| xj dz
|
|||
|
|
c_ |dz | j k( r| j « n| j
|
|||
|
|
|« || xj dz c_ | j « cddd« S # | xj dz c_ | j « w xY w# 1 sw Y yxY w)aN Wait for the barrier.
|
|||
|
|
|
|||
|
|
When the specified number of threads have started waiting, they are all
|
|||
|
|
simultaneously awoken. If an 'action' was provided for the barrier, one
|
|||
|
|
of the threads will have executed that callback prior to returning.
|
|||
|
|
Returns an individual index number from 0 to 'parties-1'.
|
|||
|
|
|
|||
|
|
NrX )rÙ r Ú_enterrD rÚ Ú_releaseÚ_waitÚ_exit)rF r[ Úindexs r& r“ z Barrier.wait¾ s´ € ð ˆ?Ø—m‘mˆGØ
|
|||
|
|
�Z‰Zñ Ø �K‰KŒMØ—K‘KˆEØ �KŠK˜1Ñ �Kð
|
|||
|
|
ؘ1‘9 §
|
|||
|
|
¡
|
|||
|
|
Ò-à—M‘M•Oð —J‘J˜wÔ'Ø à— ’ ˜qÑ • à—
|
|||
|
|
‘
|
|||
|
|
” ÷ ñ øð — ’ ˜qÑ • à—
|
|||
|
|
‘
|
|||
|
|
• ú÷ ð ús# ›2C Á5B2Â%C Â2'CÃC à C%c ó¾ — | j dv r)| j j « | j dv rŒ)| j dk rt ‚| j dk( sJ ‚y )N©ru rX r )rÛ r r“ r rE s r& râ zBarrier._enterÜ sO € Ø�k‰k˜WÑ$à �J‰J�O‰OÔ ð �k‰k˜WÒ$ð �;‰;˜Š?Ü$Ð $Ø�{‰{˜aÒ Ð Ñ r% c ó¬ — | j r| j « d| _ | j j « y # | j « ‚ xY w)NrX )rØ rÛ r r Ú_breakrE s r& rã zBarrier._releaseç sA € ð Ø�|Š|Ø— ‘ ”àˆDŒKØ �J‰J× !Ñ !Õ #øð à �K‰KŒMØ ús ‚=A Á Ac ó¼ ‡ — ‰ j j ˆ fd„|« s‰ j « t ‚‰ j dk rt ‚‰ j dk( sJ ‚y )Nc ó" •— ‰ j dk7 S r@ ©rÛ rE s €r& ú<lambda>z Barrier._wait.<locals>.<lambda>ö s ø€ ¨D¯K©K¸1Ñ,<€ r% r rX )r rš rê r rÛ ©rF r[ s ` r& rä z
|
|||
|
|
Barrier._waitõ sJ ø€ Ø�z‰z×"Ñ"Ó#<¸gÔFà �K‰KŒMÜ$Ð $Ø �;‰;˜Š?Ü$Ð $Ø�{‰{˜aÒ Ð Ñ r% c ó„ — | j dk( r1| j dv r"d| _ | j j « y y y )Nr rè )rD rÛ r r rE s r& rå z
|
|||
|
|
Barrier._exit s; € Ø �;‰;˜!Ò Ø�{‰{˜gÑ%à �” Ø—
|
|||
|
|
‘
|
|||
|
|
×%Ñ%Õ'ð &ð r% c ó — | j 5 | j dkD r.| j dk( rd| _ n | j dk( rd| _ nd| _ | j j « ddd« y# 1 sw Y yxY w)z�Reset the barrier to the initial state.
|
|||
|
|
|
|||
|
|
Any threads currently waiting will get the BrokenBarrier exception
|
|||
|
|
raised.
|
|||
|
|
|
|||
|
|
r ru éþÿÿÿN)r rD rÛ r rE s r& Úresetz
|
|||
|
|
Barrier.reset sj € ð �Z‰Zñ $Ø�{‰{˜QŠØ—;‘; !Ò#à"$�D•KØ—[‘[ BÒ&ð #%�D•Kà �” Ø �J‰J× !Ñ !Ô #÷ $÷ $ñ $ús �A A5Á5A>c óf — | j 5 | j « ddd« y# 1 sw Y yxY w)zÃPlace the barrier into a 'broken' state.
|
|||
|
|
|
|||
|
|
Useful in case of error. Any currently waiting threads and threads
|
|||
|
|
attempting to 'wait()' will have BrokenBarrierError raised.
|
|||
|
|
|
|||
|
|
N)r rê rE s r& Úabortz
|
|||
|
|
Barrier.abort s) € ð �Z‰Zñ Ø �K‰KŒM÷ ÷ ñ ús �'§0c óF — d| _ | j j « y )Nrò )rÛ r r rE s r& rê zBarrier._break% s € 𠈌 Ø �
|
|||
|
|
‰
|
|||
|
|
× Ñ Õ r% c ó — | j S )z:Return the number of threads required to trip the barrier.)rÚ rE s r& rÜ zBarrier.parties+ s € ð �}‰}Ð r% c ó: — | j dk( r | j S y)z>Return the number of threads currently waiting at the barrier.r )rÛ rD rE s r& rà zBarrier.n_waiting0 s € ð
|
|||
|
|
�;‰;˜!Ò Ø—;‘;Ð Ør% c ó — | j dk( S )z0Return True if the barrier is in a broken state.rò rí rE s r& rß zBarrier.broken9 s € ð �{‰{˜bÑ Ð r% ©NNrc )rv rO rP rw rG rT r“ râ rã rä rå ró rõ rê ÚpropertyrÜ rà rß r$ r% r& r r ž su „ ñóò >ó ò< ò
|
|||
|
|
ò ò(ò$ò(ò ð ñ ó ð ð ñó ðð ñ!ó ñ!r% r c ó — e Zd Zy)r N)rv rO rP r$ r% r& r r ? s „ Ør% r rX c ó — | t « z S rc )Ú_counter)Ú
|
|||
|
|
name_templates r& Ú_newnamer E s € Ø œ8›:Ñ %Ð%r% c ó€ — t D � cg c] } | j « rŒ| ‘Œ }} t j |« yc c} w )a!
|
|||
|
|
Drop any shutdown locks that don't correspond to running threads anymore.
|
|||
|
|
|
|||
|
|
Calling this from time to time avoids an ever-growing _shutdown_locks
|
|||
|
|
set when Thread objects are not joined explicitly. See bpo-37788.
|
|||
|
|
|
|||
|
|
This must be called with _shutdown_locks_lock acquired.
|
|||
|
|
N)Ú_shutdown_locksrI Údifference_update)r€ Ú to_removes r& Ú_maintain_shutdown_locksr W s3 € ô #2ÖG˜$¸¿¹½ ’ÐG€IÐGÜ×%Ñ% iÕ0ùò Hs ‰;Ÿ;c ó& — e Zd ZdZdZ d ddœd„Zd„ Zd„ Zd„ Zd „ Z d
|
|||
|
|
„ Z
|
|||
|
|
d „ Z e rd „ Z
|
|||
|
|
d
|
|||
|
|
„ Zd„ Zd„ Zd„ Zd d„Zd d„Zed„ « Zej, d„ « Zed„ « Ze red„ « Zd„ Zed„ « Zej, d„ « Zd„ Zd„ Z d „ Z d „ Z y)!r a A class that represents a thread of control.
|
|||
|
|
|
|||
|
|
This class can be safely subclassed in a limited fashion. There are two ways
|
|||
|
|
to specify the activity: by passing a callable object to the constructor, or
|
|||
|
|
by overriding the run() method in a subclass.
|
|||
|
|
|
|||
|
|
FN)Údaemonc ó, — |�J d« ‚|€i }|r t |« }n#t d« }|� |j }|d|› d�z
|
|||
|
|
}|| _ || _ || _ || _ |� |rt « s t d« ‚|| _
|
|||
|
|
nt « j | _
|
|||
|
|
d| _
|
|||
|
|
t rd| _ d| _ t# « | _ d| _ d| _ t* j, | _ t1 « | _ t4 j7 | « y# t $ r Y ŒÓw xY w) aU This constructor should always be called with keyword arguments. Arguments are:
|
|||
|
|
|
|||
|
|
*group* should be None; reserved for future extension when a ThreadGroup
|
|||
|
|
class is implemented.
|
|||
|
|
|
|||
|
|
*target* is the callable object to be invoked by the run()
|
|||
|
|
method. Defaults to None, meaning nothing is called.
|
|||
|
|
|
|||
|
|
*name* is the thread name. By default, a unique name is constructed of
|
|||
|
|
the form "Thread-N" where N is a small decimal number.
|
|||
|
|
|
|||
|
|
*args* is a list or tuple of arguments for the target invocation. Defaults to ().
|
|||
|
|
|
|||
|
|
*kwargs* is a dictionary of keyword arguments for the target
|
|||
|
|
invocation. Defaults to {}.
|
|||
|
|
|
|||
|
|
If a subclass overrides the constructor, it must make sure to invoke
|
|||
|
|
the base class constructor (Thread.__init__()) before doing anything
|
|||
|
|
else to the thread.
|
|||
|
|
|
|||
|
|
Nz#group argument must be None for nowz Thread-%dz (ú)z4daemon threads are disabled in this (sub)interpreterFT) Ústrr rv ÚAttributeErrorÚ_targetÚ_nameÚ_argsÚ_kwargsÚ_daemon_threads_allowedr` Ú _daemonicr
|
|||
|
|
r Ú_identÚ_HAVE_THREAD_NATIVE_IDÚ
|
|||
|
|
_native_idÚ _tstate_lockr Ú_startedÚ _is_stoppedÚ _initializedr/ ÚstderrÚ_stderrÚ_make_invoke_excepthookÚ_invoke_excepthookÚ _danglingÚadd)rF ÚgroupÚtargetrL r; r< r Ú target_names r& rG zThread.__init__r s € ð. ˆ}ÐCÐ CÓCˆ}Ø ˆ>؈FÙ Ü�t“9‰Dä˜KÓ(ˆDØÐ!ðØ"(§/¡/�Kؘb
|
|||
|
|
¨QÐ /Ñ/�D𠈌 ؈Œ
|
|||
|
|
؈Œ
|
|||
|
|
Ø ˆŒ Ø Ð ÙÔ 5Ô 7Ü"Ð#YÓZÐZØ #ˆD�Nä +Ó -× 4Ñ 4ˆDŒN؈Œ Ý !Ø "ˆDŒOØ ˆÔÜ ›ˆŒ
|
|||
|
|
Ø ˆÔØ ˆÔä—{‘{ˆŒ Ü"9Ó";ˆÔ ä�
|
|||
|
|
‰
|
|||
|
|
�dÕøô1 &ò Ùðús ªD Ä DÄDc óÜ — | j j « |rB| j �5| j j « | j j « y y d| _ d | _ y r# )r rV r rY r )rF Úis_alives r& Ú_reset_internal_locksz Thread._reset_internal_locks® s` € ð
|
|||
|
|
�
|
|||
|
|
‰
|
|||
|
|
×%Ñ%Ô'Ù ð × Ñ Ð,Ø×!Ñ!×1Ñ1Ô3Ø×!Ñ!×)Ñ)Õ+ð -ð $ˆDÔ Ø $ˆDÕ r% c óR — | j sJ d« ‚d}| j j « rd}| j « | j rd}| j
|
|||
|
|
r|dz
|
|||
|
|
}| j �|d| j z z
|
|||
|
|
}d| j j ›d| j ›d |›d
|
|||
|
|
�S ) Nz Thread.__init__() was not calledÚinitialÚstartedÚstoppedz daemonz %sr± ú(z, z)>)
|
|||
|
|
r r rÏ r# r r r rN rv r
|
|||
|
|
)rF rÌ s r& rT zThread.__repr__¿ s’ € Ø× Ò ÐDÐ"DÓDÐ ØˆØ �=‰=× Ñ Ô !Ø ˆFØ �
|
|||
|
|
‰
|
|||
|
|
ŒØ × Ò Ø ˆFØ �>Š>Ø �iÑ ˆFØ �;‰;Ð "Ø �e˜dŸk™kÑ)Ñ )ˆFøØ!%§ ¡ ×!8Ó!8¸$¿*»*ÂfÐMÐMr% c ó† — | j s t d« ‚| j j « r t d« ‚t 5 | t
|
|||
|
|
| < ddd« t
|
|||
|
|
| j d« | j j « y# 1 sw Y Œ;xY w# t $ r$ t 5 t
|
|||
|
|
| = ddd« ‚ # 1 sw Y ‚ xY ww xY w)a- Start the thread's activity.
|
|||
|
|
|
|||
|
|
It must be called at most once per thread object. It arranges for the
|
|||
|
|
object's run() method to be invoked in a separate thread of control.
|
|||
|
|
|
|||
|
|
This method will raise a RuntimeError if called more than once on the
|
|||
|
|
same thread object.
|
|||
|
|
|
|||
|
|
z thread.__init__() not calledz threads can only be started onceNr$ )
|
|||
|
|
r r` r rÏ Ú_active_limbo_lockÚ_limboÚ_start_new_threadÚ
|
|||
|
|
_bootstrapÚ Exceptionr“ rE s r& Ústartz Thread.startÍ s« € ð × Ò Ü Ð =Ó>Ð >à �=‰=× Ñ Ô !Ü Ð AÓBÐ Bä
|
|||
|
|
ñ Ø ŒF�4‰L÷ ð Ü ˜dŸo™o¨rÔ 2ð
|
|||
|
|
|
|||
|
|
�
|
|||
|
|
‰
|
|||
|
|
×ÑÕ ÷ ð ûô ò Ü#ñ
|
|||
|
|
!ܘ4�L÷
|
|||
|
|
!à ÷
|
|||
|
|
!à úð ús0 Á
|
|||
|
|
BÁB ÂBÂC Â"B3Â* C Â3B< Â8C c óŒ — | j �& | j | j i | j ¤Ž | ` | `| `y# | ` | `| `w xY w)aX Method representing the thread's activity.
|
|||
|
|
|
|||
|
|
You may override this method in a subclass. The standard run() method
|
|||
|
|
invokes the callable object passed to the object's constructor as the
|
|||
|
|
target argument, if any, with sequential and keyword arguments taken
|
|||
|
|
from the args and kwargs arguments, respectively.
|
|||
|
|
|
|||
|
|
N)r r r rE s r& Úrunz
|
|||
|
|
Thread.runç sI € ð 7Ø�|‰|Ð'Ø �— ‘ ˜dŸj™jÐ9¨D¯L©LÒ9ð � ˜d˜j¨$©,ø�� ˜d˜j¨$©,ús ‚2; »Ac óZ — | j « y # | j rt €Y y ‚ xY wrc )Ú_bootstrap_innerr r/ rE s r& r. zThread._bootstrapø s+ € ð Ø × !Ñ !Õ #øð Ø�~Š~¤$ ,ÙØ ús ‚ “*©*c ó" — t « | _ y rc )r r rE s r& Ú
|
|||
|
|
_set_identzThread._set_ident s € Ü “kˆ� r% c ó" — t « | _ y rc )r( r rE s r& Ú_set_native_idzThread._set_native_id s € Ü +›oˆD�Or% c óø — t « | _ | j j « | j s9t 5 t « t j | j « ddd« yy# 1 sw Y yxY w)z”
|
|||
|
|
Set a lock object which will be released by the interpreter when
|
|||
|
|
the underlying thread state (see pystate.h) gets deleted.
|
|||
|
|
N)Ú
|
|||
|
|
_set_sentinelr rY r Ú_shutdown_locks_lockr r r rE s r& Ú_set_tstate_lockzThread._set_tstate_lock sc € ô
|
|||
|
|
*›OˆÔØ ×Ñ×!Ñ!Ô#à�{Š{Ü%ñ
|
|||
|
|
7Ü(Ô*Ü ×#Ñ# D×$5Ñ$5Ô6÷
|
|||
|
|
7ð
|
|||
|
|
7ð ÷
|
|||
|
|
7ð
|
|||
|
|
7ús ¼*A0Á0A9c ó( — | j « | j « t r| j « | j j « t 5 | t | j < t | = d d d « t rt j t « t rt j t « | j « | j# « y # 1 sw Y ŒixY w# | j! | « Y Œ2xY w# | j# « w xY wrc )r6 r< r r8 r rÊ r+ rK r r, r4 r/ r r+ r r2 r Ú_deleterE s r& r4 zThread._bootstrap_inner sÀ € ð Ø �O‰OÔ Ø × !Ñ !Ô #Ý%Ø×#Ñ#Ô%Ø �M‰M× Ñ Ô Ü#ñ
|
|||
|
|
!Ø'+”˜Ÿ ™ Ñ$ܘ4�L÷
|
|||
|
|
!õ Ü—
|
|||
|
|
‘
|
|||
|
|
œkÔ*Ý Ü—‘¤
|
|||
|
|
Ô.ð
|
|||
|
|
.Ø—‘”
|
|||
|
|
ð
|
|||
|
|
�L‰L�N÷
|
|||
|
|
!ð
|
|||
|
|
!ûð
|
|||
|
|
.Ø×'Ñ'¨Ö-ûà �L‰L�Nús7 ‚AC? ÁCÁ3AC? Â:C' ÃC$à C? Ã'C<Ã:C? Ã?Dc óÄ — | j }|�|j « rJ ‚d| _ d | _ | j st 5 t « d d d « y y # 1 sw Y y xY wr# )r rI r r r; r r s r& Ú_stopz Thread._stop7 sc € ð" × Ñ ˆØ Ð Ø—{‘{”}Ð $Ð$Ø ˆÔØ ˆÔØ�{Š{Ü%ñ
|
|||
|
|
+ä(Ô*÷
|
|||
|
|
+ð
|
|||
|
|
+ð ÷
|
|||
|
|
+ð
|
|||
|
|
+ús Á AÁA c óX — t 5 t t « = ddd« y# 1 sw Y yxY w)zARemove current thread from the dict of currently running threads.N)r+ rK r rE s r& r> zThread._deleteR s$ € ä
|
|||
|
|
ñ %Üœ › Ð$÷ %÷ %ñ %ús ‡ )c ó — | j s t d« ‚| j j « s t d« ‚| t « u r t d« ‚|€| j « y| j t
|
|||
|
|
|d« ¬« y)a Wait until the thread terminates.
|
|||
|
|
|
|||
|
|
This blocks the calling thread until the thread whose join() method is
|
|||
|
|
called terminates -- either normally or through an unhandled exception
|
|||
|
|
or until the optional timeout occurs.
|
|||
|
|
|
|||
|
|
When the timeout argument is present and not None, it should be a
|
|||
|
|
floating point number specifying a timeout for the operation in seconds
|
|||
|
|
(or fractions thereof). As join() always returns None, you must call
|
|||
|
|
is_alive() after join() to decide whether a timeout happened -- if the
|
|||
|
|
thread is still alive, the join() call timed out.
|
|||
|
|
|
|||
|
|
When the timeout argument is not present or None, the operation will
|
|||
|
|
block until the thread terminates.
|
|||
|
|
|
|||
|
|
A thread can be join()ed many times.
|
|||
|
|
|
|||
|
|
join() raises a RuntimeError if an attempt is made to join the current
|
|||
|
|
thread as that would cause a deadlock. It is also an error to join() a
|
|||
|
|
thread before it has been started and attempts to do so raises the same
|
|||
|
|
exception.
|
|||
|
|
|
|||
|
|
ú Thread.__init__() not calledz'cannot join thread before it is startedzcannot join current threadNr )r[ )r r` r rÏ r
|
|||
|
|
Ú_wait_for_tstate_lockÚmaxrï s r& Újoinz Thread.join[ sv € ð0 × Ò Ü Ð =Ó>Ð >Ø�}‰}×#Ñ#Ô%Ü Ð HÓIÐ IØ ”>Ó#Ñ #Ü Ð ;Ó<Ð <à ˆ?Ø × &Ñ &Õ (ð
|
|||
|
|
× &Ñ &¬s°7¸A«Ð &Õ ?r% c ó — | j }|€| j sJ ‚y |j ||« r!|j « | j « y y # |j « r |j « | j « ‚ xY wrc )r r rY ra r@ rI )rF Úblockr[ r€ s r& rD z Thread._wait_for_tstate_lock� sw € ð × Ñ ˆØ ˆ<à×#Ò#Ð #Ð#Ø ð Ø�|‰|˜E 7Ô+Ø— ‘ ”Ø—
|
|||
|
|
‘
|
|||
|
|
• ð ,øð Ø�{‰{Œ}ð
|
|||
|
|
— ‘ ”Ø—
|
|||
|
|
‘
|
|||
|
|
” Ø ús Ÿ2A Á3Bc ó@ — | j sJ d« ‚| j S )z¸A string used for identification purposes only.
|
|||
|
|
|
|||
|
|
It has no semantics. Multiple threads may be given the same name. The
|
|||
|
|
initial name is set by the constructor.
|
|||
|
|
|
|||
|
|
rC )r r
|
|||
|
|
rE s r& rL z Thread.nameœ s# € ð × Ò Ð@Ð"@Ó@Ð Ø�z‰zÐr% c óJ — | j sJ d« ‚t |« | _ y )NrC )r r
|
|||
|
|
r
|
|||
|
|
)rF rL s r& rL z Thread.name§ s" € à× Ò Ð@Ð"@Ó@Рܘ“Yˆ�
|
|||
|
|
r% c ó@ — | j sJ d« ‚| j S )a4 Thread identifier of this thread or None if it has not been started.
|
|||
|
|
|
|||
|
|
This is a nonzero integer. See the get_ident() function. Thread
|
|||
|
|
identifiers may be recycled when a thread exits and another thread is
|
|||
|
|
created. The identifier is available even after the thread has exited.
|
|||
|
|
|
|||
|
|
rC )r r rE s r& Úidentz Thread.ident¬ s# € ð × Ò Ð@Ð"@Ó@Ð Ø�{‰{Ðr% c ó@ — | j sJ d« ‚| j S )zïNative integral thread ID of this thread, or None if it has not been started.
|
|||
|
|
|
|||
|
|
This is a non-negative integer. See the get_native_id() function.
|
|||
|
|
This represents the Thread ID as reported by the kernel.
|