594 lines
277 KiB
Plaintext
594 lines
277 KiB
Plaintext
|
rust
|
|||
|
|
NR #rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼�§Ì± -a7a40eb546f9e2b0Á
|
|||
|
|
scopeguardÁ Âå|A}=ÝU \`ð.j -f245d02bea2a9ebfÁ ë&Gf·Ã ¬ëñq:¤»b -bb76018b1173caf6Á‰ á,½ ¶<™ arc_lockÁT£ ¤™ I ÷¶<ÏÍTÙ¤Ï ManuallyDropÁd¨¶<‚ÍTŒ¤‚ ÷ ݶ<¼ÍTƤ¼
|
|||
|
|
StableAddressÁl’¶<é
|
|||
|
|
owning_refÁdó´é DeserializeÁ\ȶ<¨ serdeÁ<²Œ¨ DeserializerÁdÕ¶/˜(&( SerializeÁLã¶P˜IGI
|
|||
|
|
SerializerÁTî¶r˜kik
|
|||
|
|
ArcMutexGuardÁl³Â¶<µÁÍT¿Á¤µÁËI û¶<ÓÍTݤÓË€d¬¶<†ÍT�¤†Ë÷ á¶<ÀÍTʤÀËÈl–¶<íåd÷´íËý\̶<¬˜<¶Œ¬Ë«dÙ¶ ˜ ËÏLç¶8˜646ËðTò¶Q˜OMOË ArcReentrantMutexGuardÁ´èá¶<áàÍTëà¤áà»I ÷¶<ÏÍT٤ϻ€d¨¶<‚ÍTŒ¤‚»÷ ݶ<¼ÍTƤ¼»Èl’¶<éådó´é»ý\ȶ<¨˜<²Œ¨»«dÕ¶ ˜ »ÏLã¶8˜646»ðTî¶Q˜OMO» ArcRwLockReadGuardÁ”š¥¶<›¤ÍT¥¤¤›¤» ArcRwLockWriteGuardÁœÄ�¶<ÅŒÍTÏŒ¤ÅŒ» ArcRwLockUpgradableReadGuardÁ䵫¶<¶ªÍTÀª¤¶ª ³ _ GuardSendÁ
|
|||
|
|
ì GuardNoSendÁ
|
|||
|
|
ì mutexÁ RawMutexÁ INITÁ GuardMarkerÁ lockÁ try_lockÁ unlockÁ is_lockedÁ RawMutexFairÁ unlock_fairÁ bumpÁ
|
|||
|
|
RawMutexTimedÁ � ¯ try_lock_forÁ try_lock_untilÁ Ë " RÁ "™ "@ " dataÁ 'Ì '™ *Ì *™ -Ì -™ -• -
|
|||
|
|
into_innerÁ 2Ì 2™ 2 from_rawÁ 2 const_newÁ 7Ì 7™ 7 make_guard_uncheckedÁ 7” 7Ÿ 7 get_mutÁ 7» 7 force_unlockÁ 7@ 7 data_ptrÁ BÌ B™ B force_unlock_fairÁ FÌ F™ F� F° KÌ K™ K> OÌ O™ Oï SÌ S™ SÍ V LockedPlaceholderÁ W
|
|||
|
|
V YÍ
|
|||
|
|
[ 'aÁ [Ì [™ _¢ _Ì _™ _À
|
|||
|
|
_…
|
|||
|
|
d UÁ d FÁ _ try_mapÁ gà gè _ try_map_or_errÁ jà jè j EÁ _ unlockedÁ nè nà _ leakÁ r¢ rÌ r™ rÞ r
|
|||
|
|
unlocked_fairÁ wè wà rð
|
|||
|
|
{¢ {Ì {™ {š {‚ �¢ �Ì �™ �„ †¢ †Ì †™ †² ‹¢ ‹Ì ‹™ ‹Í �¢ �Ì �™ �Í •¢ •Ì •™ ™¢ ™Ì ™™ �¢ �Ì �™ �…
|
|||
|
|
¡à ¡è �ð ¤à ¤è �Œ §à §è §¯ «¢ «Ì «™ «Þ °¢ °Ì °™ °š °‚ ¶¢ ¶Ì ¶™ ¶„ »¢ »Ì »™ »² À¢ ÀÌ À™ ÀÍ Å¢ ÅÌ Å™ ÅÍ remutexÁ Ë ËËËËËËËËË Ë
|
|||
|
|
Ë Ë Ë
|
|||
|
|
ËËËËË GetThreadIdÁ Þ÷
|
|||
|
|
Þ nonzero_thread_idÁ Ë RawReentrantMutexÁ áÌ á GÁ á ownerÁ á
|
|||
|
|
lock_countÁ áÀ
|
|||
|
|
á
|
|||
|
|
get_thread_idÁ Ë èÌ è¥ ËëÌ ë¥ ËîÌ î¥ î÷
|
|||
|
|
î
|
|||
|
|
lock_internalÁ òè î” ô îŸ ö î® î» î is_owned_by_current_threadÁ ËûÌ û¥ ûÞ ûð Ë€Ì €¥ €° ƒ €� … Ë ReentrantMutexÁ ‡Ì ‡¥ ‡™ ‡@ ‡á Ë�Ì �¥ �™ Ë‘Ì ‘¥ ‘™ Ë•Ì •¥ •™ •• •©
|
|||
|
|
Ë›Ì ›¥ ›™ ›Ì
|
|||
|
|
›Û
|
|||
|
|
Ë ¡Ì ¡¥ ¡™ ¡ý
|
|||
|
|
¡” ¡Ÿ ¡¦ ¡» ¡ø ¡» ¡@ ¡Ô Ë
|
|||
|
|
®Ì ®¥ ®™ ®õ Ë ³Ì ³¥ ³™ ³� ³° Ë ¹Ì ¹¥ ¹™ ¹> Ë
|
|||
|
|
¾Ì ¾¥ ¾™ ¾ï ËÃÌ Ã¥ Ù ÃÍ Ç÷ È
|
|||
|
|
Ç ÊÍ ËÌ¢ ÌÌ Ì¥ Ì™ ËÑ¢ ÑÌ Ñ¥ Ñ™ Ñç Ñ…
|
|||
|
|
×à ×è Ñð Úà Úè ÑŒ Ýà Ýè ݯ Ñ· áè áà Ëä¢ äÌ ä¥ ä™ äÞ äÿ êè êà äð Ëî¢ îÌ î¥ î™ îš î‚ Ëõ¢ õÌ õ¥ õ™ õ² Ëû¢ ûÌ û¥ û™ ûÍ Ë�¢ �Ì �¥ �™ �Í Ë‡¢ ‡Ì ‡¥ ‡™ ËŒ¢ ŒÌ Œ¥ Œ™ Œ…
|
|||
|
|
‘à ‘è Œð ”à ”è ŒŒ —à —è —¯ Ë›¢ ›Ì ›¥ ›™ ›Þ Ë¡¢ ¡Ì ¡¥ ¡™ ¡š ¡‚ ˨¢ ¨Ì ¨¥ ¨™ ¨² Ë®¢ ®Ì ®¥ ®™ ®Í Ë ´¢ ´Ì ´¥ ´™ ´Í rwlockÁ » »»»»»»» RawRwLockÁ Ã÷
|
|||
|
|
 à lock_sharedÁ à try_lock_sharedÁ Ã
|
|||
|
|
unlock_sharedÁ à lock_exclusiveÁ à try_lock_exclusiveÁ à unlock_exclusiveÁ û à is_locked_exclusiveÁ »
|
|||
|
|
RawRwLockFairÁ Î unlock_shared_fairÁ Î unlock_exclusive_fairÁ Î bump_sharedÁ Î bump_exclusiveÁ » RawRwLockDowngradeÁ Ó downgradeÁ » RawRwLockTimedÁ Õ� Õ¯ Õ try_lock_shared_forÁ Õ try_lock_shared_untilÁ Õ try_lock_exclusive_forÁ Õ try_lock_exclusive_untilÁ » RawRwLockRecursiveÁ Ü lock_shared_recursiveÁ Ü try_lock_shared_recursiveÁ » RawRwLockRecursiveTimedÁ ß try_lock_shared_recursive_forÁ ß try_lock_shared_recursive_untilÁ » RawRwLockUpgradeÁ â lock_upgradableÁ â try_lock_upgradableÁ â unlock_upgradableÁ â upgradeÁ â try_upgradeÁ » RawRwLockUpgradeFairÁ è unlock_upgradable_fairÁ è bump_upgradableÁ » RawRwLockUpgradeDowngradeÁ ë downgrade_upgradableÁ ë downgrade_to_upgradableÁ » RawRwLockUpgradeTimedÁ î try_lock_upgradable_forÁ î try_lock_upgradable_untilÁ î try_upgrade_forÁ î try_upgrade_untilÁ »„ óÌ ó™ ó@ óá » øÌ ø™ »ûÌ û™ »þÌ þ™ þ• þ©
|
|||
|
|
»ƒÌ ƒ™ ƒÌ
|
|||
|
|
ƒÛ
|
|||
|
|
»ˆÌ ˆ™ ˆ make_read_guard_uncheckedÁ ˆ make_write_guard_uncheckedÁ ˆ readÁ ˆ try_readÁ ˆ writeÁ ˆ try_writeÁ ˆ¦ ˆ» ˆ§' ˆ force_unlock_readÁ ˆ force_unlock_writeÁ ˆ@ ˆÔ »˜Ì ˜™ ˜ force_unlock_read_fairÁ ˜ force_unlock_write_fairÁ »�Ì �™ � try_read_forÁ � try_read_untilÁ �
|
|||
|
|
try_write_forÁ � try_write_untilÁ »¤Ì ¤™ ¤ read_recursiveÁ ¤ try_read_recursiveÁ »©Ì ©™ © try_read_recursive_forÁ © try_read_recursive_untilÁ » ®Ì ®™ ® make_upgradable_guard_uncheckedÁ ® upgradable_readÁ ® try_upgradable_readÁ »
|
|||
|
|
´Ì ´™ ´ try_upgradable_read_forÁ ´ try_upgradable_read_untilÁ » ¹Ì ¹™ ¹> » ½Ì ½™ ½ï »
|
|||
|
|
ÁÌ Á™ ÁÍ »ÅÌ Å™ »È¢ ÈÌ È™ ÈÆ% È…
|
|||
|
|
Íà Íè Èð Ðà Ðè ÈŒ Óà Óè Ó¯ È· ×è ×à »Ú¢ ÚÌ Ú™ ÚÞ Úÿ ßè ßà Úð »ã¢ ãÌ ã™ ãš ã‚ »é¢ éÌ é™ é² »î¢ îÌ î™ îÍ »ó¢ óÌ ó™ óÍ »øÌ ø™ »û¢ ûÌ û™ ûÆ% û…
|
|||
|
|
€à €è ûð ƒà ƒè ûŒ †à †è †¯ û· Šè Šà »�¢ �Ì �™ �Ñ( »’¢ ’Ì ’™ ’Ô- »—¢ —Ì —™ —Þ —ÿ œè œà —ð » ¢ Ì ™ š ‚ »¦¢ ¦Ì ¦™ ¦„ » «¢ «Ì «™ «² » °¢ °Ì °™ °Í » µ¢ µÌ µ™ µÍ » º¢ ºÌ º™ » ¾¢ ¾Ì ¾™ ¾Æ% ¾· Ãè Ãà ¾¤, ¾³, »!È¢ ÈÌ È™ ÈÞ Èÿ Íè Íà Èð »"Ñ¢ ÑÌ Ñ™ ÑÑ( Ñ
|
|||
|
|
with_upgradedÁ Ö RetÁ Öè Ñ try_with_upgradedÁ ÙÓ? Ùè »#Ü¢ ÜÌ Ü™ ÜÐ. Üç. »$⢠âÌ â™ â try_with_upgraded_forÁ æÓ? æè â try_with_upgraded_untilÁ éÓ? éè »%ì¢ ìÌ ì™ ìš ì‚ »&ò¢ òÌ ò™ ò² »'÷¢ ÷Ì ÷™ ÷Í »(ü¢ üÌ ü™ üÍ »)�¢ �Ì �™ »*…¢ …Ì …™ »+‰¢ ‰Ì ‰™ ‰…
|
|||
|
|
�à �è ‰ð �à �è ‰ try_map_or_elseÁ “à “è “¯ »,—¢ —Ì —™ —Þ »-œ¢ œÌ œ™ œš œ‚ ».¢¢ ¢Ì ¢™ ¢² »/§¢ §Ì §™ §Í »0¬¢ ¬Ì ¬™ ¬Í »1±¢ ±Ì ±™ »2µ¢ µÌ µ™ »3¹¢ ¹Ì ¹™ ¹…
|
|||
|
|
½à ½è ¹ð Àà Àè ¹Œ Ãà Ãè ï »4Ç¢ ÇÌ Ç™ ÇÞ »5Ì¢ ÌÌ Ì™ Ìš Ì‚ »6Ò¢ ÒÌ Ò™ Ò„ »7×¢ ×Ì ×™ ײ »8Ü¢ ÜÌ Ü™ ÜÍ »9ᢠáÌ á™ áÍ Ì ç¢ çÌ ç™ çÀ
|
|||
|
|
ç‡
|
|||
|
|
n w MappedMutexGuardÁ ï¢ ïÌ ï™ ï@ ïá ï‡
|
|||
|
|
Ë ReentrantMutexGuardÁ ö¢ öÌ ö¥ ö™ öç ö‡
|
|||
|
|
á ê Ë MappedReentrantMutexGuardÁ ÿ¢ ÿÌ ÿ¥ ÿ™ ÿ@ ÿá ÿ‡
|
|||
|
|
»… ‡¢ ‡Ì ‡™ ‡Æ% ‡‡
|
|||
|
|
× ß »† �¢ �Ì �™ �Æ% �‡
|
|||
|
|
Š œ » RwLockUpgradableReadGuardÁ —¢ —Ì —™ —Æ% —‡
|
|||
|
|
Ã Í Ö Ù æ é » MappedRwLockReadGuardÁ £¢ £Ì £™ £@ £á £‡
|
|||
|
|
» MappedRwLockWriteGuardÁ ª¢ ªÌ ª™ ª@ ªá ª‡
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
!
|
|||
|
|
:
|
|||
|
|
;
|
|||
|
|
<
|
|||
|
|
=
|
|||
|
|
>
|
|||
|
|
?
|
|||
|
|
@
|
|||
|
|
A
|
|||
|
|
E
|
|||
|
|
I
|
|||
|
|
J
|
|||
|
|
V
|
|||
|
|
V
|
|||
|
|
V
|
|||
|
|
Z
|
|||
|
|
Z
|
|||
|
|
Z
|
|||
|
|
c
|
|||
|
|
d
|
|||
|
|
g
|
|||
|
|
j
|
|||
|
|
n
|
|||
|
|
w
|
|||
|
|
z
|
|||
|
|
€
|
|||
|
|
…
|
|||
|
|
Š
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
”
|
|||
|
|
”
|
|||
|
|
”
|
|||
|
|
¡
|
|||
|
|
¤
|
|||
|
|
§
|
|||
|
|
µ
|
|||
|
|
º
|
|||
|
|
¿
|
|||
|
|
Ä
|
|||
|
|
Ä
|
|||
|
|
Ä
|
|||
|
|
É
|
|||
|
|
É
|
|||
|
|
É
|
|||
|
|
à
|
|||
|
|
ò
|
|||
|
|
ô
|
|||
|
|
ö
|
|||
|
|
ø
|
|||
|
|
ù
|
|||
|
|
ú
|
|||
|
|
þ
|
|||
|
|
ÿ
|
|||
|
|
ƒ
|
|||
|
|
…
|
|||
|
|
¥
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
¨
|
|||
|
|
©
|
|||
|
|
ª
|
|||
|
|
«
|
|||
|
|
¬
|
|||
|
|
|
|||
|
|
²
|
|||
|
|
·
|
|||
|
|
¸
|
|||
|
|
Ç
|
|||
|
|
Ç
|
|||
|
|
Ç
|
|||
|
|
Ë
|
|||
|
|
Ë
|
|||
|
|
Ë
|
|||
|
|
Ö
|
|||
|
|
×
|
|||
|
|
Ú
|
|||
|
|
Ý
|
|||
|
|
á
|
|||
|
|
ê
|
|||
|
|
í
|
|||
|
|
ô
|
|||
|
|
ú
|
|||
|
|
€
|
|||
|
|
€
|
|||
|
|
€
|
|||
|
|
†
|
|||
|
|
†
|
|||
|
|
†
|
|||
|
|
‘
|
|||
|
|
”
|
|||
|
|
—
|
|||
|
|
§
|
|||
|
|
|
|||
|
|
³
|
|||
|
|
³
|
|||
|
|
³
|
|||
|
|
¹
|
|||
|
|
¹
|
|||
|
|
¹
|
|||
|
|
Æ
|
|||
|
|
Ç
|
|||
|
|
È
|
|||
|
|
É
|
|||
|
|
Ê
|
|||
|
|
Ë
|
|||
|
|
Ì
|
|||
|
|
Í
|
|||
|
|
Ï
|
|||
|
|
Ð
|
|||
|
|
Ñ
|
|||
|
|
Ò
|
|||
|
|
Ô
|
|||
|
|
Ø
|
|||
|
|
Ù
|
|||
|
|
Ú
|
|||
|
|
Û
|
|||
|
|
Ý
|
|||
|
|
Þ
|
|||
|
|
à
|
|||
|
|
á
|
|||
|
|
ã
|
|||
|
|
ä
|
|||
|
|
å
|
|||
|
|
æ
|
|||
|
|
ç
|
|||
|
|
é
|
|||
|
|
ê
|
|||
|
|
ì
|
|||
|
|
í
|
|||
|
|
ï
|
|||
|
|
ð
|
|||
|
|
ñ
|
|||
|
|
ò
|
|||
|
|
‹
|
|||
|
|
Œ
|
|||
|
|
�
|
|||
|
|
Ž
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
‘
|
|||
|
|
’
|
|||
|
|
“
|
|||
|
|
”
|
|||
|
|
•
|
|||
|
|
–
|
|||
|
|
—
|
|||
|
|
›
|
|||
|
|
œ
|
|||
|
|
|
|||
|
|
¡
|
|||
|
|
¢
|
|||
|
|
£
|
|||
|
|
§
|
|||
|
|
¨
|
|||
|
|
¬
|
|||
|
|
|
|||
|
|
±
|
|||
|
|
²
|
|||
|
|
³
|
|||
|
|
·
|
|||
|
|
¸
|
|||
|
|
Ä
|
|||
|
|
Ä
|
|||
|
|
Ä
|
|||
|
|
Å
|
|||
|
|
Ì
|
|||
|
|
Í
|
|||
|
|
Ð
|
|||
|
|
Ó
|
|||
|
|
×
|
|||
|
|
ß
|
|||
|
|
â
|
|||
|
|
è
|
|||
|
|
í
|
|||
|
|
ò
|
|||
|
|
ò
|
|||
|
|
ò
|
|||
|
|
÷
|
|||
|
|
÷
|
|||
|
|
÷
|
|||
|
|
ø
|
|||
|
|
ÿ
|
|||
|
|
€
|
|||
|
|
ƒ
|
|||
|
|
†
|
|||
|
|
Š
|
|||
|
|
œ
|
|||
|
|
Ÿ
|
|||
|
|
¥
|
|||
|
|
ª
|
|||
|
|
¯
|
|||
|
|
´
|
|||
|
|
´
|
|||
|
|
´
|
|||
|
|
¹
|
|||
|
|
¹
|
|||
|
|
¹
|
|||
|
|
Â
|
|||
|
|
Ã
|
|||
|
|
Í
|
|||
|
|
Ð
|
|||
|
|
Ö
|
|||
|
|
Ö
|
|||
|
|
Ù
|
|||
|
|
Ù
|
|||
|
|
æ
|
|||
|
|
æ
|
|||
|
|
é
|
|||
|
|
é
|
|||
|
|
ñ
|
|||
|
|
ö
|
|||
|
|
û
|
|||
|
|
û
|
|||
|
|
û
|
|||
|
|
€
|
|||
|
|
€
|
|||
|
|
€
|
|||
|
|
�
|
|||
|
|
�
|
|||
|
|
“
|
|||
|
|
¡
|
|||
|
|
¦
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
«
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
½
|
|||
|
|
À
|
|||
|
|
Ã
|
|||
|
|
Ñ
|
|||
|
|
Ö
|
|||
|
|
Û
|
|||
|
|
à
|
|||
|
|
à
|
|||
|
|
à
|
|||
|
|
å
|
|||
|
|
å
|
|||
|
|
å
|
|||
|
|
ÞÃÎÓÕÜßâèëî„ Ÿ
|
|||
|
|
ì Ï ¶o<Gy ¨â " " Ë %@ &á ˆüPwTµ¹¼ Ì ™ „ �Y Ä�Y ú�Y¹Y à`�Y à` W W X÷ èÚb«ïïÀN „ ç ç Ì ëÀ
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA ¢Ì ™ ì šZ ù šZ � šZ à`šZ å`šZ „ ï ï �I ó@ ôá õ‡
|
|||
|
|
ì2ò<âª}A ¢×ZÝZ ¨âœ[ ì œ[ ù œ[ � œ[ à`œ[ å`œ[ ¨â á á „ ä® Ë å» Ë æÀ
|
|||
|
|
Ë çÕ Ë XÊ9WN<¶ ³Y¥ „ ®\ ¨â ‡ ‡ î ‹@ Ë Œá Ë œM¸öq0.³Y‚]ÝZ „ š] Äš] úš]ÝZ à`š] à` È È É÷ ÌTR�èï „ ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî ¢×Z¥™ ì ¹^ � ¹^ à`¹^ å`¹^ „ ÿ ÿ «J „@ Ë …á Ë †‡
|
|||
|
|
Ë ówñkŒhÄð ¢×Zû^�_ ì ¶_ � ¶_ à`¶_ å`¶_ ¨â ó ó „ ö@ » ÷á » +$B’Z[e³Y¹Y „ ¹` Ĺ` ú¹`¹Y à`¹` „ ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä 8×ZÝZ ì ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä ¢×ZÝZ � ôa à`ôa å`ôa „ � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh 8×ZÝZ ì � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh ¢×ZÝZ ù ©c � ©c à`©c å`©c „ — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö ¢×ZÝZ ì �d � �d à`�d å`�d „ £ £ ÞL §@ » ¨á » ©‡
|
|||
|
|
» èkˆÂ¿ m ¢×ZÝZ ¨â‘e ì ‘e � ‘e à`‘e å`‘e „ ª ª ªM ®@ » ¯á » °‡
|
|||
|
|
» ã/S!&”p ¢×ZÝZ ¨â›f ì ›f ù ›f � ›f à`›f å`›f
|
|||
|
|
* "[ ç• ïë á‘ ‡Ì ö‡ ÿû óÅ ‡ø �º —� £± ª' "™ ïè á� ‡ø ó… £µ ªK "¹ ‡¹ óO "¾ ‡½ óS "Y W‹ çÀ ïà ‡Ê Èû ö® ÿÁ óî ‡° �÷ —§ £Ü ª{ ç° ïî ö¡ ÿã ‡ �ì —œ £Ì ª� ç¶ ï¦ �Ò ª† ç» ïõ ö¨ ÿé ‡« �ò —¢ £× ª� çÅ ï� ö´ ÿó ‡µ �ü —¬ £á ª„ è¨â]Ä/úà`ì ^ù >� å` ?<ö* ³Y ³Y ¤‘+ ¡+
|
|||
|
|
" |‘+
|
|||
|
|
Î.¹Y 3 D ¤+ üÝ*S
|
|||
|
|
" ³Y¹Y ¯+ ¶+ ü«*‹ 0 �Y \Ç* ¹Y ¼* ³Y å Ç.Ç.
|
|||
|
|
UnsafeCellÁ É.˜¸+ ö)=ê „9Û¹Y ¹Y –Z ‰D ³Y ³Y L•. ¤². Â.
|
|||
|
|
" |². �l - > Å. üü-U
|
|||
|
|
" ³Y¹Y Ð. ×. ü·- 5 �Y \æ- ³Y LÍ- ¹Y Û- ³Y Ý ¬m Ñ ¹Y Ð raw_mutexÁ3 –7 o L¢1 1 ô“1
|
|||
|
|
t“1
|
|||
|
|
5³Y¹Y J < 2 °1 ·1 üÍ0j 6 �Y \ý0 ³Y Lä0 ¹Y ò0 ³Y ¬ ¹Y ‘o# –' ^ œ�
|
|||
|
|
„�
|
|||
|
|
¸¸ ® > dÆ
|
|||
|
|
LÆ
|
|||
|
|
ê,Õr Ð Õr A <ã ³Y ³Y <ƒ ß‚] ‚] üú—
|
|||
|
|
á ³Y‚] � ü㯠ñ ®\ $ó ®¸®¸ b ¯¸ vÁÓZ iVwƒ' [ É,É, q Ë,˜¸+ »\¡Ø Ê–Õr M ³Y ‚] ú Ÿ# ³Y ³Y ß‚] ‚] _Á ¤¢= ²=
|
|||
|
|
" |¢=
|
|||
|
|
Î.ÝZ 3 D µ= üÉ=¿ œô=
|
|||
|
|
„ô= ¼r …> Õr ; d¥>
|
|||
|
|
L¥>ÿr ¯> Õr < <Ê> ³Y ³Y <ò> ß‚] ‚] Æ
|
|||
|
|
á ³Y‚] ‡? üÿ<”
|
|||
|
|
‡ ³Y‚]ÝZ ’? ™? üÁ<Ø ™ š] ¼Ý< ÝZ Ò< Ç.Ç. ¶l É.˜¸+ ö)=ê „9ÛÝZ ý ÝZ ý ®\ ½ Ët » �u „ ³Y L ‚] 6 –q ¡m ³Y ³Y] ß‚] ‚] ¤ãB óB
|
|||
|
|
" |ãB §v - > öB üŠC¸ œµC
|
|||
|
|
„µC ¼r ÆC Õr ; dæC
|
|||
|
|
LæCÿr ðC Õr < L‹D l¦D
|
|||
|
|
|
|||
|
|
¯
|
|||
|
|
á ³Y‚]
|
|||
|
|
ÁD
|
|||
|
|
üÀB�
|
|||
|
|
‡ ³Y‚]ÝZ ÌD ÓD ÒD üÝAö Ÿ š] ¼žB ³Y LóA ‚] l�B ÝZ “B Åy ç ÝZ ç ®\ Ët « �u t ³Y < ‚] 1 ‘oV ÕZ –^ L‚H l�H œH üóG-
|
|||
|
|
|
|||
|
|
tóG
|
|||
|
|
Ÿ³Y‚]ÝZ b T F < ŸH ¦H ü�G— š] ¼ÑG ³Y L¦G ‚] l´G ÝZ ÆG ³Y Ú ‚] Î ÝZ  ‘o3 Õ7 –; } ¤Èj Øj
|
|||
|
|
" |Èj �l - > Ûj <ïj ijY ³Y üjT
|
|||
|
|
ó ³Y¹Y €k ‡k üúi� � ¹` d–j ¹Y ‹j ¬m Ò ¹Y Ñ ³Y – –! Q® ijY ³Y ¤»n Ën
|
|||
|
|
" |»n �l - > În Tân ü nW
|
|||
|
|
ó ³Y¹Y ön ýn ün üÙm¤ † ¹` d‰n ³Y Tïm ¹Y þm ¬m á ¹Y à ³Y ¥
|
|||
|
|
raw_rwlockÁ4 –8 q Tþq Šr üïq
|
|||
|
|
|
|||
|
|
tïq
|
|||
|
|
†³Y¹Y L > 4 �r ”r ü§qm ‡ ¹` dØq ³Y T¾q ¹Y Íq ³Y ¯ ¹Y £ à„$ –( ` ¤�
|
|||
|
|
# „
|
|||
|
|
ì ¡ÞKB´H˜ W ^ e ´Œ
|
|||
|
|
# ÍX . 7 > Ë»³ _T† è
|
|||
|
|
DÊ ÊË d• Êû l ÊË,ã' " ÊÐ\‘
|
|||
|
|
Þ º„Œ” á ºîtá8 ‡ º÷%L» à æÂ'l× Î æ·(”é) Ó æâ(t£. Õ æþ)”Š7 Ü æÖ*¼–: ß æÁ+„Â@ â æÆ,¤âH è æ—-Ì P ë æó-¬£U î æ„4ªb ó æÌT̆ ç Ê�I„Äã ï ÊÖIœ¡¥ ö º«JÌÁ� ÿ º…|´ë ‡ 憄ÆÄ � æ÷KÌ»¼ — æÞL¬¥œ £ æªM´ðÉ ª æüÍ» üÍO L This library provides type-safe and fully-featured [`Mutex`] and [`RwLock`]Á ü�H E types which wrap a simple raw mutex or rwlock type. This has severalÁ üæG D benefits: not only does it eliminate a large portion of the work inÁ ü®O L implementing custom lock types, it also allows users to write code which isÁ üþ; 8 generic with regards to different lock implementations.Á º Ë ü¾6 3 Basic usage of this crate is very straightforward:Á õ Ë üùO L 1. Create a raw lock type. This should only contain the lock state, not anyÁ üÉ" data protected by the lock.Á üì@ = 2. Implement the `RawMutex` trait for your custom lock type.Á üC @ 3. Export your mutex as a type alias for `lock_api::Mutex`, andÁ üñC @ your mutex guard as a type alias for `lock_api::MutexGuard`.Á üµ5 2 See the [example](#example) below for details.Á ë Ë üïN K This process is similar for [`RwLock`]s, except that two guards need to beÁ ü¾ O L exported instead of one. (Or 3 guards if your type supports upgradable readÁ üŽ
|
|||
|
|
G D locks, see [extension traits](#extension-traits) below for details)Á Ö
|
|||
|
|
Ë lÚ
|
|||
|
|
|
|||
|
|
# ExampleÁ è
|
|||
|
|
Ë <ì
|
|||
|
|
```Á üô
|
|||
|
|
/ , use lock_api::{RawMutex, Mutex, GuardSend};Á ü¤ 2 / use std::sync::atomic::{AtomicBool, Ordering};Á × Ë üÛ " // 1. Define our raw lock typeÁ üþ ' $ pub struct RawSpinlock(AtomicBool);Á ¦ Ë üª * ' // 2. Implement RawMutex for this typeÁ üÕ * ' unsafe impl RawMutex for RawSpinlock {Á ü€
|
|||
|
|
F C const INIT: RawSpinlock = RawSpinlock(AtomicBool::new(false));Á Ç
|
|||
|
|
Ë üË
|
|||
|
|
L I // A spinlock guard can be sent to another thread and unlocked thereÁ ü˜% " type GuardMarker = GuardSend;Á ¾ Ë Ä fn lock(&self) {Á üÛO L // Note: This isn't the best way of implementing a spinlock, but itÁ ü«5 2 // suffices for the sake of this example.Á üá% " while !self.try_lock() {}Á L‡ }Á ‘ Ë ü•$ ! fn try_lock(&self) -> bool {Á ”º self.0Á üÍT Q .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)Á Ä¢ .is_ok()Á L» ¼œ Å Ë üÉ! unsafe fn unlock(&self) {Á üë3 0 self.0.store(false, Ordering::Release);Á LŸ ¼œ ,© }Á ¯ Ë ü³T Q // 3. Export the wrappers. This are the types that your users will actually use.Á üˆ; 8 pub type Spinlock<T> = lock_api::Mutex<RawSpinlock, T>;Á üÄM J pub type SpinlockGuard<'a, T> = lock_api::MutexGuard<'a, RawSpinlock, T>;Á <’ —– š Ë ´ž # Extension traitsÁ µ Ë ü¹O L In addition to basic locking & unlocking functionality, you have the optionÁ ü‰K H of exposing additional functionality in your lock types by implementingÁ üÕE B additional traits for it. Examples of extension features include:Á › Ë üŸ6 3 - Fair unlocking (`RawMutexFair`, `RawRwLockFair`)Á üÖ7 4 - Lock timeouts (`RawMutexTimed`, `RawRwLockTimed`)Á üŽ8 5 - Downgradable write locks (`RawRwLockDowngradable`)Á üÇ1 . - Recursive read locks (`RawRwLockRecursive`)Á üù0 - - Upgradable read locks (`RawRwLockUpgrade`)Á ª Ë ü®O L The `Mutex` and `RwLock` wrappers will automatically expose this additionalÁ üþI F functionality if the raw lock type implements these extension traits.Á È Ë ¤Ì # Cargo featuresÁ á Ë üå- * This crate supports three cargo features:Á “ Ë ü—R O - `owning_ref`: Allows your lock types to be used with the `owning_ref` crate.Á üêk h - `arc_lock`: Enables locking from an `Arc`. This enables types such as `ArcMutexGuard`. Note that thisÁ üÖ/ , requires the `alloc` crate to be present.Á Ë»³# _$ è
|
|||
|
|
# ÊË " Êû ! ÊË " ÊÐ Þ º„ á ºî ‡ º÷% à æÂ' Î æ·( Ó æâ( Õ æþ) Ü æÖ* ß æÁ+ â æÆ, è æ—- ë æó- î æ„ ó æÌ ç Ê�I ï ÊÖI
|
|||
|
|
ö º«J ÿ º… ‡ æ† � æ÷K — æÞL £ æªM ª æ ¼ù á üÅ I F Marker type which indicates that the Guard type for a lock is `Send`.Á Lš ˆ ¡ÞKB´H˜ ˆ h3 ˆ
|
|||
|
|
¤ @ üª M J Marker type which indicates that the Guard type for a lock is not `Send`.Á \— ÍX Ï ¶o<Gy š‰ÍX Ê2 š‰ÍX
|
|||
|
|
<£ š‰ü® ÍX LÓ ,× "çï¶lTÝ Ç. Í ó Á]
|
|||
|
|
PhantomDataÁ\Š ‰ ˲ Š memÁ ¡ Õ †,¶ ì DerefMutÁD½ ù ´Ñ�Lí�ÌüxL›TäªGI02̹ üü! Basic operations for a mutex.Á žË ü¢K H Types implementing this trait can be used by `Mutex` to form a safe andÁ üî! fully-functioning mutex type.Á �Ë d” # SafetyÁ ¡Ë ü¥H E Implementations of this trait must ensure that the mutex is actuallyÁ üîJ G exclusive: a lock can't be acquired while the mutex is already locked.Á ªâ ü¹Þ „¸ „¸ ©â Œ¸ Œ¥ Á¸ „û
|
|||
|
|
üÙ( % Initial value for an unlocked mutex.Á$� Œ¸„¥ ü’ K H Marker type which determines whether a lock guard should be `Send`. UseÁ üâ > ; one of the `GuardSend` or `GuardNoSend` helper types here.Á\ª |�
|
|||
|
|
ü¼ O L Acquires this mutex, blocking the current thread until it is able to do so.Á$“
|
|||
|
|
± ±Œ¸ ˜
|
|||
|
|
|
|||
|
|
Œ¸$™
|
|||
|
|
ܲ ü¥
|
|||
|
|
C @ Attempts to acquire this mutex without blocking. Returns `true`Á üí
|
|||
|
|
@ = if the lock was successfully acquired and `false` otherwise.ÁDµ ² ²Œ¸ ¾
|
|||
|
|
Œ¸$¿ÄŸ ¼Ó Unlocks this mutex.Á ïË d÷¯µ ˆË ü�\ Y This method may only be called if the mutex is held in the current context, i.e. it mustÁ üñg d be paired with a successful call to [`lock`], [`try_lock`], [`try_lock_for`] or [`try_lock_until`].Á ÝË äå [`lock`]: RawMutex::lockÁ ü†$ ! [`try_lock`]: RawMutex::try_lockÁ ü¯1 . [`try_lock_for`]: RawMutexTimed::try_lock_forÁ üå5 2 [`try_lock_until`]: RawMutexTimed::try_lock_untilÁ4© ³ ³Œ¸ °
|
|||
|
|
Œ¸$±Ü� ü½1 . Checks whether the mutex is currently locked.ÁL„ ´ ´Œ¸ Ž
|
|||
|
|
Œ¸$�ü„' ü™@ = Additional methods for mutexes which support fair unlocking.Á ÚË üÞP M Fair unlocking means that a lock is handed directly over to the next waitingÁ ü¯K H thread if there is one, without giving other threads the opportunity toÁ üûJ G "steal" the lock in the meantime. This is typically slower than unfairÁ üÆ= : unlocking, but may be necessary in certain circumstances.Á w „¸ü„Ö Œ¸ D£ „¸( ŠÇ „¸4 ŠÇ) ìŸ ü²4 1 Unlocks this mutex using a fair unlock protocol.Á ëË dó¯µ „Ë üŒS P This method may only be called if the mutex is held in the current context, seeÁ üä6 3 the documentation of [`unlock`](RawMutex::unlock).Á\© µ µŒ¸ µ
|
|||
|
|
Œ¸$¶¬Š üÂE B Temporarily yields the mutex to a waiting thread if there is one.Á ŒË ü”L I This method is functionally equivalent to calling `unlock_fair` followedÁ üåL I by `lock`, however it can be much more efficient in the case where thereÁ ܶ are no waiting threads.Á Ö Ë dÞ ¯µ ï Ë ü÷ S¹Ç üÏ 6•È$” ¶ ¶Œ¸ ™
|
|||
|
|
Œ¸$š ü± ( üÜ G D Additional methods for mutexes which support locking with timeouts.Á ¤ Ë ü¨ P M The `Duration` and `Instant` types are specified as associated types so thatÁ üù 7 4 this trait is usable even in `no_std` environments.Á Ê" „¸ü± ² ŠÇDÑ „¸! ŠÇ „¸- ŠÇ) ! ! ©â Œ¸ t�! ¦Ð ©â Œ¸ lÓ! ÄÐ ! l�! üà * ' Duration type used for `try_lock_for`.ÁD”! dÓ! ü£!+ ( Instant type used for `try_lock_until`.Á<Ø! ü¨"8 üæ!= : Attempts to acquire this lock until a timeout is reached.Ád«" · ·Œ¸ ®Ð ¸"
|
|||
|
|
Œ¸$¹" timeoutÁ<¿"ü¨#9 üæ"=‰Ñt«# ¸ ¸Œ¸ ÌÐ º#
|
|||
|
|
!Œ¸$»#™Ò<Á#ôØ' üå#B ? A mutual exclusion primitive useful for protecting shared dataÁ ¨$Ë ü¬$O L This mutex will block threads waiting for the lock to become available. TheÁ üü$C @ mutex can also be statically initialized or created via a `new`Á üÀ%O L constructor. Each mutex has a type parameter which represents the data thatÁ ü�&K H it is protecting. The data can only be accessed through the RAII guardsÁ üÜ&O L returned from `lock` and `try_lock`, which guarantees that the data is onlyÁ ü¬'+ ( ever accessed when the mutex is locked.Á 9' Ì # ™ $ # $
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA ¹³Y¹Y 7 ÷4 7
|
|||
|
|
:³Y¹Y$ø4ü£:* üü5L I Acquires a mutex, blocking the current thread until it is able to do so.Á Í6Ë üÕ6N K This function will block the local thread until it is available to acquireÁ ü¨7K H the mutex. Upon returning, the thread is the only thread with the mutexÁ üø7L I held. An RAII guard is returned to allow scoped unlock of the lock. WhenÁ üÉ8< 9 the guard goes out of scope, the mutex will be unlocked.Á Š9Ë ü’9L I Attempts to lock a mutex in the thread which already holds the lock willÁ Ìã9 result in a deadlock.Á R|�:$ª:€ º º�Y ç ç Ì ëÀ
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA º³Y¹Y 7 ¯: 7
|
|||
|
|
;³Y¹Y$°:ü�>6 üÕ;" Attempts to acquire this lock.Á ü;Ë ü„<L I If the lock could not be acquired at this time, then `None` is returned.Á üÕ<L I Otherwise, an RAII guard is returned. The lock will be unlocked when theÁ ¬¦= guard is dropped.Á À=Ë üÈ=! This function does not block.Á R|ü=D—>€ » »�Y ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ç ç Ì ëÀ
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA »³Y¹Y 7 > 7
|
|||
|
|
<³Y¹Y$¡>ü€B# ü�@7 4 Returns a mutable reference to the underlying data.Á Ì@Ë üÔ@K H Since this call borrows the `Mutex` mutably, no actual locking needs toÁ ü¤AI F take place---the mutable borrow statically guarantees no locks exist.Á<‡B ¼ ¼�Y ¼¹Y 7 �B 7
|
|||
|
|
=³Y¹Y$”Bü²C üÚB1ÇÁ R|žCL¹C€ ½ ½�Y 7 ÃC 7
|
|||
|
|
>³Y¹Y$ÄCü€H! üüC Forcibly unlocks the mutex.Á DË ü¨DJ G This is useful when combined with `mem::forget` to hold a lock withoutÁ ü÷DF C the need to maintain a `MutexGuard` object alive, for example whenÁ ¬ÂE dealing with FFI.Á ÜEË däE¯µ õEË üýEJ G This method must only be called if the current thread logically owns aÁ üÌFG D `MutexGuard` but that guard has been discarded using `mem::forget`.Á ü˜GA > Behavior is undefined if a mutex is unlocked when not locked.Á R|ìGdŽH€ ¾ ¾�Y 7 ›H 7
|
|||
|
|
?³Y¹Y$œHôÁK üÊH, ) Returns the underlying raw mutex object.Á ûHË üƒIK H Note that you will most likely need to import the `RawMutex` trait fromÁ üÓI= : `lock_api` to be able to call functions on the raw mutex.Á •JË d�J¯µ ®JË ü¶JC @ This method is unsafe because it allows unlocking a mutex whileÁ üþJ0 - still holding a reference to a `MutexGuard`.Á ÏK ¿ ¿�Y ¿³Y 7 ÓK 7
|
|||
|
|
@³Y¹Y$ÔKü…P üÿK1 . Returns a raw pointer to the underlying data.Á µLË ü½LJ©ô üŒMFüô ¬×MÊõ ñMË dùM¯µ ŠNË ü’NG D You must ensure that there are no data races when dereferencing theÁ üÞNF C returned pointer, for example if the current thread logically ownsÁ ü©OI F a `MutexGuard` but that guard has been discarded using `mem::forget`.ÁDŒP À À�Y ¹Y 7 •P 7
|
|||
|
|
A³Y¹Y$–PüÇ], Ì C ™ D D C ôØ Ì] „Ù Ý] ³Y dÏ]�YE ! $& ü›b& üú]< 9 Forcibly unlocks the mutex using a fair unlock protocol.Á »^Ë üÃ^J©ô ü’_Füô ¬Ý_Êõ ÷_Ë dÿ_¯µ �`Ë ü˜`JŠö üç`GÝö ü³aA÷ R|‡bŒ©b€ Á Á�Y B »b B
|
|||
|
|
E³Y¹Y$¼büíb- Ì G ™ H H G ôØ òb „Ù „c ³Y lõb�YIJ !# &( ü×eP ü¡c=‰Ñ ãcË üëcF C If the lock could not be acquired before the timeout expired, thenÁ ü¶dK H `None` is returned. Otherwise, an RAII guard is returned. The lock willÁ ü†e* ' be unlocked when the guard is dropped.Á R|ÃedÞe€  Â�Y ³Y ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ç ç Ì ëÀ
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA ³Y¹Y F ëe F
|
|||
|
|
I³Y¹Y$ìe™Ò<òeü²jQ üüg=‰Ñ ¾hË üÆhF�„ ü‘iKß„ üái*³… R|žjt¹j€ à Ã�Y ³Y ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ç ç Ì ëÀ
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA óY¹Y F Èj F
|
|||
|
|
J³Y¹Y$Éj™Ò<ÏjüŽw> Ì L ™ M M L ôØ “w „Ù w ¯ÚD–w ĹY <¬w�YN Å N /1 46 Üáw<äw �Y K K
|
|||
|
|
N³Y¹Yü¯x, Ì P ™ Q P Q ôØ ´x Ü Áx ¯ÚD·x�YR ü R " %' äðx$óx ¹Y�Y O O
|
|||
|
|
R³Y¹Y tÁ øxü®yD Ì T ™ U U T ôØ ³y „Ù Ày ¯ÚD¶y à`¹Y TÌy�YV á` V /1 46 üùy8 üy Ä Å Æ Ä�Y ÅÁ`Á` œ Ã`è Á] Ä` bufÁÁ] Ê\É:• Æê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ ѼѼҼ” štÀ. S €z S
|
|||
|
|
V³Y¹Y$�zþ ‡zÄÏ{ ŒÖ{ ñY èÚb«ïïÀN X +' W W ñYüù{% ñYZ á` Z üµ|8 ¸| Ç È É ÇñY ÈÁ`Á` œ Ã`è Á] Ä`·ŽÁ] Ê\É:• ÉÝ� Y ¼| Y
|
|||
|
|
Z $½|þ Ã|üʇ] ¢ \ Ì ] ™ ^ \ ] ^ ©â×Z Ú‡ ªâÝZ ó‡ ×Z D݇ „ ×Z $è‡ ×Z ¢ï‡ „ ÝZ $ÿ‡ ÝZ ¢†ˆšZ Ö‡mo \km \ü¬ˆ? ¢ ` Ì a ™ b b a ` Ñ“ µˆ ⓠLj ó“D¸ˆ ’”È ±”ÓˆšZcdgjnq ±ˆ?A `EG `ü®‰) üòˆ7 4 Returns a reference to the original `Mutex` object.Á,µ‰ Ê ÊšZ ¢ " " Ë %@ &á ˆüPwTµ¹¼×ZÝZ _ ¾‰ _
|
|||
|
|
c ¢×ZÝZö »‰ü„�t üõ‰F C Makes a new `MappedMutexGuard` for a component of the locked data.Á ÀŠË üÈŠ9 6 This operation cannot fail as the `MutexGuard` passedÁ ü†‹ in already locked the mutex.Á «‹Ë ü³‹3 0 This is an associated function that needs to beÁ üë‹L I used as `MutexGuard::map(...)`. A method would interfere with methods ofÁ ü¼Œ5 2 the same name on the contents of the locked data.Á ‹� šZè ï ï �I ó@ ôá õ‡
|
|||
|
|
ì2ò<âª}A ¢×Zà _à e è f e f _ ªâú› �� ©â«› š� Ë ™ «› ËÝZ Äß� Ë «›Ýœ› Ëú›4ñ�
|
|||
|
|
d ¢×ZÝZú›«›ö ��þ ¦��� ˆŠ üÊ“Ž üæ�D A Attempts to make a new `MappedMutexGuard` for a component of theÁ ü¯�N K locked data. The original guard is returned if the closure returns `None`.Á ‚‘Ë üŠ‘9Ê— üÈ‘ �˜ í‘Ë üõ‘3Ø ü’P M used as `MutexGuard::try_map(...)`. A method would interfere with methods ofÁ ü‚“5Ö™<Ñ“ šZ«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘°›šZ _à h è i h i _ ©œ Ù“ »œ ä“ Ì ™ «› ÌÝZ ü·” Ì «›÷¡› ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> Ìú›tÉ”
|
|||
|
|
g ¢×ZÝZú›«›ö ç“þ ð“ÉË ÍÏ ü¯›· üŸ—Dîœ üè—M J locked data. The original guard is returned alongside arbitrary user dataÁ üº˜! if the closure returns `Err`.Á à˜Ë üè˜9Ê— ü¦™ �˜ Ë™Ë üÓ™3Ø ü‹šW T used as `MutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁ üçš5Ö™t¶› šZ«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘°›šZ¯ _à k è l ¯ m l m k _ ©œ Å› »œ Л ©âþ¦ Ó› Í ™ «› ÍÝZ üÂœ# Í «›î§› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ Íú›þ¦ŒÔœ
|
|||
|
|
j ¢×ZÝZú›«›þ¦ö ß›þ ð›íï ñó ìî ü¡¡R ü²Ÿ@ = Temporarily unlocks the mutex to execute the given function.Á ÷ŸË üÿŸD A This is safe because `&mut` guarantees that there exist no otherÁ üÈ 2 / references to the data protected by the mutex.Á R|�¡D¨¡€ ΠΚZèà _è o à p p o º¡ _ ©âï« ±¡ ©âô« ´¡ ™ ï« lå¡ ï« › ô« ñ¡
|
|||
|
|
n ¢×ZÝZï«ô«ö ·¡þ Å¡ln gi üà¤! ü©£E B Leaks the mutex guard and returns a mutable reference to the dataÁ Üó£ protected by the mutex.Á “¤Ë ü›¤2 / This will leave the `Mutex` in a locked state.Á$ç¤ šZ ¢ÝZ _ _
|
|||
|
|
q ¢×ZÝZö ì¤üä¥C ¢ s Ì t ™ u s t u Ñ“ í¥ â“ ƒ¦ ×Z d𥠒”ÿ¥ ±”�¦šZvwz é¥?A sEG sÜȬ ü®¦3 0 Unlocks the mutex using a fair unlock protocol.Á æ¦Ë üî¦J G By default, mutexes are unfair and allow the current thread to re-lockÁ ü½§H E the mutex before another has the chance to acquire the lock, even ifÁ üŠ¨J G that thread has been blocked on the mutex for a long time. This is theÁ üÙ¨K H default because it allows much higher throughput as it avoids forcing aÁ ü©©G D context switch on every mutex unlock. This can result in one threadÁ üõ©9 6 acquiring a mutex many more times than other threads.Á ³ªË ü»ªL I However in some cases it can be beneficial to ensure fairness by forcingÁ üŒ«L I the lock to pass on to a waiting thread if there is one. This is done byÁ üÝ«D A using this method instead of dropping the `MutexGuard` normally.Á R|´¬\Ϭ€ šZ r r
|
|||
|
|
v ¢×ZÝZö Û¬üµ°W ü‚®@â¨ Ç®Ë üÏ®7 4 The mutex is unlocked using a fair unlock protocol.Á ‹¯Ë ü“¯D¸© üܯ2†ª R|¡°l¼°€ Ï ÏšZï«ô« rè x à y y x Ó° r ¨¬ Ê° º¬ Í° ̬lþ° ଠŠ±
|
|||
|
|
w ¢×ZÝZï«ô«ö аþ Þ°JL NP Ìý´ üDzE¨É ‘³Ë ü™³L�Ê üê³LÖÊ Ü»´ªË R|é´$„µ€ РКZ r Œµ r
|
|||
|
|
Dæ Ë ÎË dð Ë Ïû lþ Ë ÐŸ
|
|||
|
|
\’ Ë ÑŸ
|
|||
|
|
Ë Ñq$¹ É, Ë Ô¶lT¿ Ç. Ë ÕÍ Ð Á] Ë Ö˲\á ‰ Ë ×˲ Š Ë ×ý² ò Õ Ë Ø NonZeroUsizeÁd€ º’ Ë Ù†,— ì Ë Úb\± ®¸ Ë ÜÕD¾ д Ë ÝüÑOJM<?.1 #ü¦¤
|
|||
|
|
øúçéœÙÙ¯±Œû–T’†,vxdfä€
|
|||
|
|
ü€4 1 Helper trait which returns a non-zero thread ID.Á µË ü¹J G The simplest way to implement this trait is to return the address of aÁ Ô„ thread-local variable.Á ŸË d£¯µ °Ë ü´N K Implementations of this trait must ensure that no two active threads shareÁ üƒ I F the same thread ID. However the ID of a thread that has exited can beÁ üÍ 2 / re-used since that thread is no longer active.Á £D Þ Þ „¸ü€
|
|||
|
|
Ó Þ „¸ „¸ ßàßà à „¯ ”£
|
|||
|
|
Initial value.Á$µ Þ Þ Œ¸ü¥
|
|||
|
|
, üÆ G D Returns a non-zero thread ID which identifies the current thread ofÁ t’
|
|||
|
|
execution.ÁŒ¨
|
|||
|
|
æ 挸 £ £ ¤ Ï ¦ ì€ ™‘‹ÖqËîÕr Þ º
|
|||
|
|
Þ
|
|||
|
|
àŒ¸$»
|
|||
|
|
ü‰" üÕ
|
|||
|
|
H E A raw mutex type that wraps another raw mutex to provide reentrancy.Á žË ü¢I F Although this has the same methods as the [`RawMutex`] trait, it doesÁ üìH E not implement it, and should not be used in the same way, since thisÁ üµL I mutex can successfully acquire a lock multiple times in the same thread.Á ü‚G D Only use this when you know you want a raw mutex that can be lockedÁ üÊ> ; reentrantly; you probably want [`ReentrantMutex`] instead.Á µD Ì â ¥ ã â ã ôØ ¦ ©â‚] ©®\ XÊ9WN<¶ äåæç24 /1 ”²,²Ë á á Ët¼ÊTÊË á á �uDç,çË á á ³Y„õlõË á á ‚]üŠW Ì é ¥ ê é ê ôØ – †ø ª ¯ÚD™ ½Ú$¤ Þ‚] \ ¨â‚] $»®\ >@ CE üåW Ì ì ¥ í í ì ôØ ñ †ø … ¯ÚDô »Û$ÿ ‡ú\ˆ „ ‚] $–®\ 68 ;= üÁ9 Ì ï ¥ ð ï ð ôØ Æ †ø Ó ¯ÚDÉ ‡ú\Ö®\ñòôöøùú 46 9; ¤ã ü�(ü·$í î î ®\ü¦Al© Ë ç ç®\ è îè ó ó Ì î ©âœý · ™ œý „º œý › $Æ
|
|||
|
|
ò³Y‚]œý$ÍŸ DÓIK ”’ ü¾A > Acquires this mutex, blocking if it's held by another thread.Á$™ è è®\ î ž î
|
|||
|
|
ô³Y‚]$Ÿ  ô <closure_kind>Á õ <closure_signature>Á õ <upvars>Á õ õ ô õ³Y‚] ®\ ô© üŽ C¡» üÖ @í»D° é é®\ î ¹ î
|
|||
|
|
ö³Y‚]$º å öéþ ÷ ‚ÿ ÷ ÿ ÷ ÷ ö ÷³Y‚]̀׀ܑ! üŠ > ; Unlocks this mutex. The inner mutex may not be unlocked ifÁ üÍ = : this mutex was acquired previously in the current thread.Á � Ë d— ¯µ ¨ Ë ü° N K This method may only be called if the mutex is held by the current thread.Á4Ÿ! ê ê®\ î ¦! î
|
|||
|
|
ø³Y‚]$§!ü×# ü“#1ÇÁLÞ# ë ë®\ î è# î
|
|||
|
|
ù³Y‚]$é#üû$0 ü£$E B Checks whether the mutex is currently held by the current thread.ÁÔ‚% ì ì®\ î �% î
|
|||
|
|
ú³Y‚]$ž%ü§&= Ì ü ¥ ý ý ü ôØ ¬& †ø ½& ¸�d¯& ‡ú\À&®\þÿ %' *, ü—) üë&D A Unlocks this mutex using a fair unlock protocol. The inner mutexÁ ü´'D A may not be unlocked if this mutex was acquired previously in theÁ œý' current thread.Á •(Ë d�(¯µ ®(Ë ü¶(Nï‚\¥) í í®\ û ±) û
|
|||
|
|
þ³Y‚]$²)̹. ü£+E¨É í+Ë üõ+L�Ê üÆ,LÖÊ Ü—-ªË ·-Ë d¿-¯µ Ð-Ë üØ-Nï‚$Ç. î î®\ û Ì. û
|
|||
|
|
ÿ³Y‚]$Í.ü™1> Ì � ¥ ‚ � ‚ ôØ ž1 †ø °1 »„l¡1 ‡ú\³1®\ƒ… %' *, ü®29 üÞ1=‰Ñtµ2 ï ï®\ ĉ € Ä2 €
|
|||
|
|
ƒ³Y‚]$Å2™Ò<Ë2…3 ƒéþ „ ‚ÿ „ ÿ „ „ ƒ „³Y‚]̀ـĉü‡48 ü·3=‰ÑdŽ4 ð ð®\ �‡ € ›4 €
|
|||
|
|
…³Y‚]$œ4™Ò<¢4Ý4 …éþ † ‚ÿ † ÿ † † … †³Y‚]Í€Ù€�‡üÖ8* ü‹5? < A mutex which can be recursively locked by a single thread.Á Ë5Ë üÏ5F C This type is identical to `Mutex` except for t
|
|||
|
|
Ë ÿ 9Ïî ñ³Y‚]ÝZ ¡ ˆL ¡
|
|||
|
|
¥³Y‚]ÝZ$‰Lü±R6 ü¥ML I Acquires a reentrant mutex, blocking the current thread until it is ableÁ löM
|
|||
|
|
to do so.Á ˆNË ü�NL I If the mutex is held by another thread then this function will block theÁ üáNL I local thread until it is available to acquire the mutex. If the mutex isÁ ü²OL I already held by the current thread then this function will increment theÁ üƒP@ = lock reference count and return immediately. Upon returning,Á üÈPG D the thread is the only thread with the mutex held. An RAII guard isÁ ü”QK H returned to allow scoped unlock of the lock. When the guard goes out ofÁ üäQ& # scope, the mutex will be unlocked.Á R|�R$¸R€ ò òš] ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî ò³Y‚]ÝZ ¡ ½R ¡
|
|||
|
|
¦³Y‚]ÝZ$¾RüªVB üïS"£ì –TË üžTLÙì üïTL®í ¬ÀU‚î ÚUË üâU!«î R|–VD±V€ ó óš] ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî ó³Y‚]ÝZ ¡ ºV ¡
|
|||
|
|
§³Y‚]ÝZ$»Vü¯Z# ü¶X7ºð òXË üúXT Q Since this call borrows the `ReentrantMutex` mutably, no actual locking needs toÁ üÓYIÙñ<¶Z ô ôš] ôÝZ ¡ ¾Z ¡
|
|||
|
|
¨³Y‚]ÝZ$ÃZüá[ ü‰[1ÇÁ R|Í[Lè[€ õ õš] ¡ ò[ ¡
|
|||
|
|
©³Y‚]ÝZ$ó[ü—]0 ü«\E†… R|ƒ]Ôž]€ ö öš] ¡ ¹] ¡
|
|||
|
|
ª³Y‚]ÝZ$º]ü—b! üƒ^ öó §^Ë ü¯^J©ô üþ^O L the need to maintain a `ReentrantMutexGuard` object alive, for example whenÁ ¬Ò_Êõ ì_Ë dô_¯µ …`Ë ü�`JŠö üÜ`N K `ReentrantMutexGuard` but that guard has be discarded using `mem::forget`.Á ü¯aA÷ R|ƒbd¥b€ ÷ ÷š] ¡ ²b ¡
|
|||
|
|
«³Y‚]ÝZ$³bôáe üáb,Ôø ’cË üšcK”ù üêc=èù ¬dË d´d¯µ ÅdË üÍdCÐú ü•e9 6 still holding a reference to a `ReentrantMutexGuard`.Á ïe ø øš] ø³Y ¡ óe ¡
|
|||
|
|
¬³Y‚]ÝZ$ôeüÅj ü¥f1¶ü ÛfË üãfJ©ô ü²gJ G the need to maintain a `ReentrantMutexGuard` object alive, for exampleÁ Ô�h when dealing with FFI.Á hË d¨h¯µ ¹hË üÁhGÃý ü�iH E returned pointer, for example if the current thread logically owns aÁ üÚiA > `ReentrantMutexGuard` but that guard has been discarded usingÁ ” j `mem::forget`.ÁDÌj ù ùš] ÝZ ¡ Õj ¡
|
|||
|
|
³Y‚]ÝZ$ÖjüäxH Ì ¯ ¥ ° ™ ± ¯ ° ± ôØ éx †ø úx â“ Šy ¸�dìx ‡ú\ýxš]² *, /1 46 üä}& ü³y<ó€ ôyË üüyJ©ô üËzOΰ ¬Ÿ{Êõ ¹{Ë dÁ{¯µ Ò{Ë üÚ{JŠö ü©|Ná± üü|A÷ R|Ð}Œò}€ ú úš] ® „~ ®
|
|||
|
|
²³Y‚]ÝZ$…~ü¶~I Ì ´ ¥ µ ™ ¶ ¶ ´ µ ôØ »~ †ø Í~ â“ Ý~ »„l¾~ ‡ú\Ð~š]·¸ -/ 24 79 ü¼�\ ü†=‰Ñ ÈË üÐF�„ ü›€Kß„ üë€*³… R|¨�dÃ�€ û ûš] �‡ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî û³Y‚]ÝZ ³ Ð� ³
|
|||
|
|
·³Y‚]ÝZ$Ñ�™Ò<×�ü£†] üíƒ=‰Ñ ¯„Ë ü·„F�„ ü‚…Kß„ üÒ…*³… R|�†tª†€ ü üš] ĉø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî ü³Y‚]ÝZ ³ ¹† ³
|
|||
|
|
¸³Y‚]ÝZ$º†™Ò<À†üΓZ Ì º ¥ » ™ ¼ º » ¼ ôØ Ó“ †ø à“ â“ ð“ ¯ÚDÖ“ ‡ú\ã“ ÄÝZ <ü“š]½ Å ½ GI KM OQ ü½”'<À” š] ¹ ¹
|
|||
|
|
½³Y‚]ÝZü •H Ì ¿ ¥ À ™ Á Á À ¿ ôØ ¥• †ø ²• ½™ • ¯ÚD¨• ‡ú\µ•š] ü  79 ;= ?A üý•($€– ÝZš] ¾ ¾
|
|||
|
|
³Y‚]ÝZ׌ …–üЖ` Ì Ä ¥ Å ™ Æ Æ Ä Å ôØ Õ– †ø â– â“ ò– ¯ÚDØ– ‡ú\å– €ÃTþ–š]Ç á` Ç @B DF HJ ü·—8 º— ý þ ÿ ýš] þÁ`Á` œ Ã`è Á] Ä`·ŽÁ] Ê\É:• ÿÝ� à ¾— Ã
|
|||
|
|
dzY‚]ÝZ$¿—þ Å—ÄÉ™ ŒÐ™Ë �^ ÌTR�èï É /* Ë È È �^üó™% �^Ë á` Ë ü¯š8 ²š € � ‚ €�^ �Á`Á` œ Ã`è Á] Ä`·ŽÁ] Ê\É:• ‚Ý� Ê ¶š Ê
|
|||
|
|
Ë $·šþ ½šü¿¦‰ ¢ Í Ì Î ¥ Ï ™ Ð Ï Í Ð Î Ñ“ Ϧ ©âû^ è¦ ªâ�_ „§ ó“DÒ¦ ‚”$ݦ ’”ä¦ Þû^ \ë¦ „ û^ $ù¦ û^ ¢€§ „ �_ $�§ �_ ¢—§¹^ ˦šœ Í™› ͘š ÍüΧ` ¢ Ò Ì Ó ¥ Ô ™ Õ Ó Ò Ô Õ Ñ“ ק ìÌ é§ ýÌ þ§ ó“DÚ§ ’”å§ ©Í\ì§ ÉÍú§ èÍŠ¨¹^Ö×ÚÝá Ó§]_ Òdf Òkm Òüú¨7 üµ¨@ = Returns a reference to the original `ReentrantMutex` object.Á<�© ƒ ƒ¹^ ¢ ‡ ‡ î ‹@ Ë Œá Ë œM¸öq0.×Zû^�_ Ñ Œ© Ñ
|
|||
|
|
Ö ¢×Zû^�_ö ‰©üû¬x üÑ©O L Makes a new `MappedReentrantMutexGuard` for a component of the locked data.Á ¥ªË üªB ? This operation cannot fail as the `ReentrantMutexGuard` passedÁ üôª �˜ ™«Ë ü¡«3Ø üÙ«U R used as `ReentrantMutexGuard::map(...)`. A method would interfere with methods ofÁ ü³¬5Ö™ ‚ ¹^è ÿ ÿ «J „@ Ë …á Ë †‡
|
|||
|
|
Ë ówñkŒhÄð ¢×Zû^ô« Ñà Ø è Ù Ø Ù Ñ ªâô« † ©âòÔ ‘ „ ™ òÔ „�_ „â „ òÔ®Ö› „ô« ð
|
|||
|
|
× ¢×Zû^�_ô«òÔö ”þ �‘“ ŒŽ ü賩 üê¯N K Attempts to make a new `MappedReentrantMutexGuard` for a component of theÁ ü½°L I locked data. The original guard is return if the closure returns `None`.Á Ž±Ë ü–±BúÑ üݱ �˜ ‚²Ë üŠ²3Ø ü²Y V used as `ReentrantMutexGuard::try_map(...)`. A method would interfere with methods ofÁ ü ³5Ö™<ï³ ¹^òÔê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘÷Ô¹^ Ñà Û è Ü Û Ü Ñ úÕ ÷³ ŒÖ ‚´ … ™ òÔ …�_ Äø´ … òÔäÛ› ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> …ô« T†µ
|
|||
|
|
Ú ¢×Zû^�_ô«òÔö Ž´þ Ÿ´ÌÎ ÐÒ ü�¼» üá·NÃÖ ü´¸MÛ¢ ü†¹!²£ ¬¹Ë ü´¹BúÑ üû¹ �˜ ºË ü¨º3Ø üàº` ] used as `ReentrantMutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁ üÅ»5Ö™t”¼ ¹^òÔê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘÷Ô¹^¯ Ñà Þ è ß ¯ à Þ ß à Ñ úÕ £¼ ŒÖ ®¼ ©â’à ±¼ † ™ òÔ †�_ ܬ½ † òÔŠá› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ †ô« ’àlº½
|
|||
|
|
Ý ¢×Zû^�_ô«òÔ’àö ½¼þ μðò ôö ïñ üŒÂR ü�À@⨠âÀË üêÀD¸© ü³Á2†ª R|øÁD“€ ‡ ‡¹^«›à Ñè â à ã ã â ¥Â Ñ »œ œÂ ©âèã ŸÂ ™ «› lР«› › èã ÜÂ
|
|||
|
|
á ¢×Zû^�_«›èãö ¢Âþ °Âpr km üŸÄh ¢ å Ì æ ¥ ç ™ è ç å æ è Ñ“ ¨Ä ìÌ ¾Ä ýÌ ÓÄ “°d«Ä ’”ºÄ ©Í\ÁÄ ÉÍÏÄ èÍßĹ^éêí ¤ÄWY å^` åeg åÜ±Ë üŽÅ3ñ¯ ÆÅË üÎÅJº° ü�ÆHŽ± üêÆJà± ü¹ÇK´² ü‰ÈG‰³ üÕÈ9Ú³ “ÉË ü›ÉL©´ üìÉLÿ´ ü½ÊM J using this method instead of dropping the `ReentrantMutexGuard` normally.Á R|�Ë\¸Ë€ ¹^ ä ä
|
|||
|
|
é ¢×Zû^�_ö ÄËü¢ÏW üõÌ@⨠ºÍË üÂÍ1 . The mutex is unlocked a fair unlock protocol.Á øÍË ü€ÎD¸© üÉÎ2†ª R|ŽÏl©Ï€ ˆ ˆ¹^«›èã äè ë à ì ë ì ÀÏ ä »œ ·Ï «ä ºÏ ½älëÏ Ñä ÷Ï
|
|||
|
|
ê ¢×Zû^�_«›èãö ½Ïþ ËÏNP RT ÌöÓ üÀÑE¨É ŠÒË ü’ÒL�Ê üãÒLÖÊ Ü´ÓªË R|âÓ$ýÓ€ ‰ ‰¹^ ä …Ô ä
|
|||
|
|
í ¢×Zû^�_ö ‚Ôü—Õn ¢ ï Ì ð ¥ ñ ™ ò ò ð ï ñ Ñ“ Õ ìÌ ²Õ ýÌ ÇÕ ó“D£Õ ’”®Õ ©Í\µÕ ÉÍÃÕ èÍÓÕ¹^óô í î ô œÕ`b ïgi ïnp ï\ŒÖ4‘Ö î î �_¬¯Ö,²Ö Š Š¹^ Š�_ î ¸Ö î
|
|||
|
|
ô ¢×Zû^�_$¹ÖüýÖm ¢ ö Ì ÷ ¥ ø ™ ù ö ù ÷ ø Ñ“ †× ìÌ ˜× ýÌ × ó“D‰× ’””× ©Í\›× ÉÍ©× è͹׹^ú � ú ‚×Y[ ö`b ögi ö”ÿ×$‚Ø ‹ ‹¹^ õ ‡Ø õ
|
|||
|
|
ú ¢×Zû^�_$ŒØüŸÙ€ ¢ ü Ì ý ¥ þ ™ ÿ ÿ ý þ ü Ñ“ ¨Ù ìÌ ºÙ ýÌ ÏÙ ó“D«Ù ’”¶Ù ©Í\½Ù ÉÍËÙ à`�_ TÒÙ èÍèÙ¹^€ á` € ¤Ùik üpr üwy üü¦Ú8 ©Ú Œ �
|
|||
|
|
blocking.Á ÎFË dÖF¯µ çFË üïFXÕØ\ÖG ¶ ¶Œ¸ â âG â
|
|||
|
|
猸$ãGüÑHG üõGL I Additional methods for `RwLock`s which support upgradable locks and fairÁ tÂH unlocking.Á WE è è „¸üÑHÞ âŒ¸ „øH ÎŒ¸ l‹I è „¸: Åß. Õß$ „¸L Åß@ Õß6éêéê ê é üßJ( üŸI= : Releases an upgradable lock using a fair unlock protocol.Á áIË déI¯µ úIË ü‚JXÕØ´éJ · ·Œ¸ è €K è
|
|||
|
|
錸$�Kü¾N ü�KN K Temporarily yields an upgradable lock to a waiting thread if there is one.Á àKË üèKW T This method is functionally equivalent to calling `unlock_upgradable_fair` followedÁ üÄLW T by `lock_upgradable`, however it can be much more efficient in the case where thereÁ Ü MªË ÀMË dÈM¯µ ÙMË üáMXÕØ|ÈN ¸ ¸Œ¸ è ØN è
|
|||
|
|
ꌸ$ÙNü�PQ ü±OL I Additional methods for `RwLock`s which support upgradable locks and lockÁ „þO
|
|||
|
|
downgrading.Á iE ë ë „¸ü�Pž Åß„»P ÓŒ¸ ”ÎP ë „¸2 Åß. Îæ$ „¸D Åß@ Îæ6ìíìí ì í ü�R& üçP3 0 Downgrades an upgradable lock to a shared lock.Á ŸQË d§Q¯µ ¸QË üÀQXÕؤ§R ¹ ¹Œ¸ ë ¼R ë
|
|||
|
|
쌸$½Rü‚T) üÉR7 4 Downgrades an exclusive lock to an upgradable lock.Á …SË d�S¯µ žSË ü¦SW¹ª¼ŒT º ºŒ¸ ë ¤T ë
|
|||
|
|
팸$¥Tü’UI ü¯TO L Additional methods for `RwLock`s which support upgradable locks and lockingÁ ”ÿT with timeouts.Á {E î î „¸ü’UÒ Åß„ºU öÎtÍU î „¸* Åß& öÎ$ „¸< Åß8 öÎ6ïðñòïðñò ñ ï ð ò üVC üâUF C Attempts to acquire an upgradable lock until a timeout is reached.Á¼°V » »Œ¸ ‘Á î ÈV î
|
|||
|
|
$ÉV™Ò<ÏVüÁWD üöVFÃëÌÄW ¼ ¼Œ¸ °Á î ÞW î
|
|||
|
|
ðŒ¸$ßW™Ò<åWüñYB ü‹XG D Attempts to upgrade an upgradable lock to an exclusive lock until aÁ ¼×X timeout is reached.Á óXË dûX¯µ ŒYË ü”YXÕØ|ûY ½ ½Œ¸ ‘Á î ‹Z î
|
|||
|
|
ñŒ¸$ŒZ™Ò<’ZüŸ\C ü¹ZGåí ¼…[´î ¡[Ë d©[¯µ º[Ë üÂ[XÕØŒ©\ ¾ ¾Œ¸ °Á î »\ î
|
|||
|
|
òŒ¸$¼\™Ò<Â\üŸb Äæ\ A reader-writer lockÁ ÿ\Ë üƒ]M J This type of lock allows a number of readers or at most one writer at anyÁ üÑ]O L point in time. The write portion of this lock typically allows modificationÁ ü¡^O L of the underlying data (exclusive access) and the read portion of this lockÁ üñ^: 7 typically allows for read-only access (shared access).Á ¬_Ë ü°_M J The type parameter `T` represents the data that this lock protects. It isÁ üþ_P M required that `T` satisfies `Send` to be shared across threads and `Sync` toÁ üÏ`N K allow concurrent access through readers. The RAII guards returned from theÁ üžaN K locking methods implement `Deref` (and `DerefMut` for the `write` methods)Á üía1 . to allow access to the contained of the lock.Á �E Ì ô ™ õ ô õ ôØ ±b „Ù ´b¹` +$B’Z[e ö÷&( +- 4Åb Åb» ó ó ³YœÑb$Ñb» ó ó ¬müßgH Ì ù ™ ú ú ù ôØ ëg „Ù €h óY Lîg ½Ú$úg ÍÚ$Œh¹` .0 35 ü«hO Ì ü ™ ý ü ý ôØ ·h „Ù Ìh ƒúLºh »Û$Æh ÍÚ$Øh „ ¹Y $ßh¹` 68 ;= üÿh" Ì ÿ ™ € ÿ € ôØ „i Ü ’i ƒúL‡i¹`�‚ "$ üúi( ü¨i? < Creates a new instance of an `RwLock<T>` which is unlocked.Á ‡j ¹Y¹` þ
|
|||
|
|
» üUfÏÏHä ¿³Y¹Y ˆ ¥v ˆ
|
|||
|
|
‹³Y¹Y$¦vü¥zM üµwIÙ‚ ƒxË d‹x¯µ œxË ü¤xO L This method must only be called if the thread logically holds a write lock.Á øxË ü€y^£ä üãy/ŠåÔ³z À À¹` � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh À³Y¹Y ˆ Îz ˆ
|
|||
|
|
Œ³Y¹Y$ÏzüÍ€/ üà{L I Locks this `RwLock` with shared read access, blocking the current threadÁ ì±| until it can be acquired.Á Ó|Ë üÛ|L I The calling thread will be blocked until there are no more writers whichÁ ü¬}L I hold the lock. There may be other readers currently inside the lock whenÁ Äý} this method returns.Á š~Ë ü¢~L I Note that attempts to recursively acquire a read lock on a `RwLock` whenÁ üó~B ? the current thread already holds one may result in a deadlock.Á ºË üÂH E Returns an RAII guard which will release this thread's shared accessÁ ¼�€ once it is dropped.Á R|¹€$Ô€€ Á Á¹` ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä Á³Y¹Y ˆ Ù€ ˆ
|
|||
|
|
�³Y¹Y$Ú€üë„; ü�‚> ; Attempts to acquire this `RwLock` with shared read access.Á Ó‚Ë üÛ‚M J If the access could not be granted at this time, then `None` is returned.Á üƒM J Otherwise, an RAII guard is returned which will release the shared accessÁ ¼ÿƒ when it is dropped.Á ›„Ë ü£„!«î R|ׄDò„€  ¹` ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä ³Y¹Y ˆ û„ ˆ
|
|||
|
|
Ž³Y¹Y$ü„ü�Š1 üü†I F Locks this `RwLock` with exclusive write access, blocking the currentÁ üʇ$ ! thread until it can be acquired.Á ó‡Ë üû‡F C This function will not return while other writers or other readersÁ üƈ& # currently have access to the lock.Á ñˆË üùˆK H Returns an RAII guard which will drop the write access of this `RwLock`Á ŒÉ‰ when dropped.Á R|í‰,ˆŠ€ à ù` � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh óY¹Y ˆ ŽŠ ˆ
|
|||
|
|
�³Y¹Y$�ŠüœŽ= üÊ‹? < Attempts to lock this `RwLock` with exclusive write access.Á ŽŒË ü–ŒLÙì üçŒI F Otherwise, an RAII guard is returned which will release the lock whenÁ ”µ� it is dropped.Á Ì�Ë üÔ�!«î R|ˆŽL£Ž€ Ä Ä¹` ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh ijY¹Y ˆ Ž ˆ
|
|||
|
|
�³Y¹Y$®Žü¤’# ü³�7ºð ï�Ë ü÷�L I Since this call borrows the `RwLock` mutably, no actual locking needs toÁ üÈ‘IÙñ<«’ ŠŹ` ŹY ˆ ³’ ˆ
|
|||
|
|
‘³Y¹Y$¸’üå“ üþ’@ = Checks whether this `RwLock` is currently locked in any way.Á R|Ñ“Lì“€ Æ Æ¹` ˆ ö“ ˆ
|
|||
|
|
’³Y¹Y$÷“ü‘•) ü¯”;‹ R|ý”œ˜•€ Ç Ç¹` ˆ ¬• ˆ
|
|||
|
|
“³Y¹Y$•üˆš& üï•! Forcibly unlocks a read lock.Á •–Ë ü�–J©ô üì–K H the need to maintain a `RwLockReadGuard` object alive, for example whenÁ ¬¼—Êõ Ö—Ë dÞ—¯µ ï—Ë ü÷—JŠö üƘJ G `RwLockReadGuard` but that guard has be discarded using `mem::forget`.Á ü•™L I Behavior is undefined if a rwlock is read-unlocked when not read-locked.Á R|ô™Œ–š€ È È¹` ˆ ¨š ˆ
|
|||
|
|
”³Y¹Y$©šüüž' üÞš" Forcibly unlocks a write lock.Á …›Ë ü�›J©ô üÜ›L I the need to maintain a `RwLockWriteGuard` object alive, for example whenÁ ¬œÊõ ÇœË dÏœ¯µ àœË üèœJŠö ü·�K H `RwLockWriteGuard` but that guard has be discarded using `mem::forget`.Á ü‡žN K Behavior is undefined if a rwlock is write-unlocked when not write-locked.Á R|èž”ŠŸ€ É É¹` ˆ �Ÿ ˆ
|
|||
|
|
•³Y¹Y$žŸôࢠüÖŸ9 6 Returns the underlying raw reader-writer lock object.Á ” Ë üœ L I Note that you will most likely need to import the `RawRwLock` trait fromÁ üí 6 3 `lock_api` to be able to call functions on the rawÁ ¼¨¡ reader-writer lock.Á Ä¡Ë dÌ¡¯µ Ý¡Ë üå¡CÐú ü¢. + still holding a reference to a lock guard.Á î¢ Ê Ê¹` ʳY ˆ ò¢ ˆ
|
|||
|
|
–³Y¹Y$ó¢ü⧠üž£1¶ü Ô£Ë üÜ£J©ô ü«¤I F the need to maintain a `RwLockReadGuard` or `RwLockWriteGuard` objectÁ üù¤- * alive, for example when dealing with FFI.Á «¥Ë d³¥¯µ Ä¥Ë üÌ¥GÃý ü˜¦Hý¶ üå¦M J `RwLockReadGuard` or `RwLockWriteGuard` but that guard has been discardedÁ Ä·§ using `mem::forget`.ÁDé§ Ë Ë¹` Ö€ ˆ ò§ ˆ
|
|||
|
|
—³Y¹Y$ó§ü¾Ä. Ì ™ ™ š ™ š ôØ ÃÄ „Ù ÕÄ Î³Y lÆĹ`›œ ') +- ü©É+ üóÄ> ; Forcibly unlocks a read lock using a fair unlock protocol.Á ¶ÅË ü¾ÅJ©ô ü�ÆK¨¡ ¬ÝÆÊõ ÷ÆË dÿƯµ �ÇË ü˜ÇJŠö üçÇJ½¢ ü¶ÈL‘£ R|•É´·É€ Ì Ì¹` ˜ ÎÉ ˜
|
|||
|
|
›³Y¹Y$ÏÉüÄÎ, ü‰Ê? < Forcibly unlocks a write lock using a fair unlock protocol.Á ÍÊË üÕÊJ©ô ü¤ËL“¥ ¬õËÊõ �ÌË d—̯µ ¨ÌË ü°ÌJŠö üÿÌK©¦ üÏÍNþ¦ R|°Î¼Ò΀ Í Í¹` ˜ êÎ ˜
|
|||
|
|
œ³Y¹Y$ëÎü¦Ï/ Ì ž ™ Ÿ Ÿ ž ôØ «Ï „Ù ¾Ï Õ³Y t®Ï¹` ¡¢£ -/ 13 üºÒU üÜÏM J Attempts to acquire this `RwLock` with shared read access until a timeoutÁ |®Ð is reached.Á ÂÐË üÊÐG D If the access could not be granted before the timeout expires, thenÁ ü–ÑG D `None` is returned. Otherwise, an RAII guard is returned which willÁ üâÑ1 . release the shared access when it is dropped.Á R|¦ÒdÁÒ€ Πι` ³Y Öø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä γY¹Y � ÎÒ �
|
|||
|
|
³Y¹Y$ÏÒ™Ò<ÕÒüÎ×V üðÔM®¶ |ÂÕ„· ÖÕË üÞÕG©· üªÖGú· üöÖ1˸ R|º×tÕ×€ Ï Ï¹` ³Y ×ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä ϳY¹Y � ä× �
|
|||
|
|
¡³Y¹Y$å×™Ò<ë×üìÜW ü‡ÚI F Attempts to acquire this `RwLock` with exclusive write access until aÁ ¼ÕÚ´î ñÚË üùÚG©· üÅÛGú· ü‘Ü4 1 release the exclusive access when it is dropped.Á R|ØÜlóÜ€ Рй` °ºø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh гY¹Y � �Ý �
|
|||
|
|
¢³Y¹Y$‚Ý™Ò<ˆÝü�âX ü¨ßIÛ½ ¼öß´î ’àË üšàG©· üæàGú· ü²á4ã¾ R|ùá|”â€ Ñ Ñ¹` ƒ½ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh ѳY¹Y � ¤â �
|
|||
|
|
£³Y¹Y$¥â™Ò<«âü�û3 Ì ¥ ™ ¦ ¥ ¦ ôØ •û „Ù ¬û ܳY ”˜û¹`§¨ ') +- üð�9 üÊûL�Š ì›üÕŠ ½üË üÅüL†‹ ü–ýLÛ‹ Äçý¯Œ „þË üŒþK H Unlike `read`, this method is guaranteed to succeed without blocking ifÁ üÜþK‹Ç ü¬ÿGßÇ üøÿJ¯È ŒÇ€�É Ý€Ë üå€H†Ž ¼²�׎ R|Ü�t÷�€ Ò Ò¹` ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä Ò³Y¹Y ¤ †‚ ¤
|
|||
|
|
§³Y¹Y$‡‚ü͇E üǃ>£� Š„Ë ü’„M÷� üä„MΑ ¼¶…¤’ Ò…Ë üÚ…L I This method is guaranteed to succeed if another read lock is held at theÁ ü«†M J time of the call. See the documentation for `read_recursive` for details.Á ý†Ë ü…‡!«î R|¹‡”Ô‡€ Ó Ó¹` ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä Ó³Y¹Y ¤ ç‡ ¤
|
|||
|
|
¨³Y¹Y$è‡ü·“8 Ì ª ™ « « ª ôØ ¼“ „Ù Ø“ ß³Y ¼¿“¹`¬ ') +- ü˜˜v üö“M®¶ |È”„· Ü”Ë üä”G©· ü°•Gú· üü•1˸ ²–Ë üº–I F This method is guaranteed to succeed without blocking if another readÁ üˆ—C @ lock is held at the time of the call. See the documentation forÁ üЗ! `read_recursive` for details.Á R|„˜´Ÿ˜€ Ô Ô¹` °ºø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä Ô³Y¹Y © ¿˜ ©
|
|||
|
|
¬³Y¹Y$À˜™Ò<Θü×�w üùšM®¶ |Ë›„· ß›Ë üç›G©· ü³œGú· üÿœ1˸ R|Ã�ÄÞ�€ Õ Õ¹` ƒ½ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä Õ³Y¹Y © €ž ©
|
|||
|
|
³Y¹Y$�ž™Ò<�žüŠ¬1 Ì ¯ ™ ° ¯ ° ôØ �¬ „Ù ¤¬ â³Y „’¬¹`±²³ *, .0 üŒ°[ ü¬S P Creates a new `RwLockUpgradableReadGuard` without checking if the lock is held.Á šË d¢¯µ ³Ë ü»Z W This method must only be called if the thread logically holds an upgradable read lock.Á š®Ë ü¢®]¯„ ü„¯Y•… ¼â¯ö…üš° Ö Ö¹` — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö Ö³Y¹Y ® º° ®
|
|||
|
|
±³Y¹Y$»°üɵD üÞ±P M Locks this `RwLock` with upgradable read access, blocking the current threadÁ ì³²ÕŠ Õ²Ë üݲO L The calling thread will be blocked until there are no more writers or otherÁ ü±³N K upgradable reads which hold the lock. There may be other readers currentlyÁ ü„´- * inside the lock when this method returns.Á ¶´Ë ü¾´H†Ž ¼‹µ×Ž R|µµ|е€ × ×¹` — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö ׳Y¹Y ® ൠ®
|
|||
|
|
²³Y¹Y$áµüŠºP ü«·B ? Attempts to acquire this `RwLock` with upgradable read access.Á ò·Ë üú·M÷� ü̸MΑ ¼ž¹¤’ º¹Ë ü¹!«î R|ö¹œ‘º€ Ø Ø¹` ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö سY¹Y ® ¥º ®
|
|||
|
|
³³Y¹Y$¦ºüˆÌ6 Ì µ ™ ¶ ¶ µ ôØ �Ì „Ù §Ì î³Y ¬�̹`·¸ ') +- ü§Ï� üÅÌQ N Attempts to acquire this `RwLock` with upgradable read access until a timeoutÁ |›Í„· ¯ÍË ü·ÍG©· üƒÎGú· üÏÎ1˸ R|“ϼ®Ï€ Ù Ù¹` °ºø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö Ù³Y¹Y ´ ÏÏ ´
|
|||
|
|
·³Y¹Y$ÐÏ™Ò<ÞÏüõÔ‚ ü“ÒQàà |éÒ„· ýÒË ü…ÓG©· üÑÓGú· ü�Ô1˸ R|áÔÌüÔ€ Ú Ú¹` ƒ½ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö Ú³Y¹Y ´ ŸÕ ´
|
|||
|
|
¸³Y¹Y$ Õ™Ò<®Õü×ã@ Ì º ™ » º » ôØ Üã „Ù êã ƒúLßã Ä‹<öã¹`¼ Å ¼ .0 24 ä¬ä<¯ä ¹` ¹ ¹
|
|||
|
|
¼³Y¹Yüüä. Ì ¾ ™ ¿ ¾ ¿ ôØ �å Ü �å ƒúL„å¹`À ü À %' )+ ì¿å$Âå ¹Y¹` ½ ½
|
|||
|
|
À³Y¹Y׌ ÇåüÿåF Ì Â ™ à  à ôØ „æ „Ù ’æ ƒúL‡æ ŽTžæ¹`Ä á` Ä .0 24 üÌæ8 Ïæ Û Ü Ý Û¹` ÜÁ`Á` œ Ã`è Á] Ä`·ŽÁ] Ê\É:• ÝÝ� Á Óæ Á
|
|||
|
|
ijY¹Y$Ôæþ Úæü¶ìU 8 Þ Ì Æ ™ Ç Æ Þ Ç Ñ“ Âì â“ ×ì Ã×Z LÅì ‚”$Ñì ¡”$Úì©a 35 79 ü�íE ¢ É Ì Ê ™ Ë É Ê Ë Ñ“ ™í â“ ¬í ±íLœí ’”¨í ±”¸íôaÌÍÐÓ× •íBD ÉIK Éü£î+ üÜíB ? Returns a reference to the original reader-writer lock object.Á4ªî ß ßôa ¢ ó ó „ ö@ » ÷á » +$B’Z[e×ZÝZ È ´î È
|
|||
|
|
Ì ¢×ZÝZö ±îü‰òq üíîJ G Make a new `MappedRwLockReadGuard` for a component of the locked data.Á ¼ïË üÄï> ; This operation cannot fail as the `RwLockReadGuard` passedÁ ü‡ð in already locked the data.Á «ðË ü³ð3Ø üëðQ N used as `RwLockReadGuard::map(...)`. A method would interfere with methods ofÁ üÁñ5Ö™ �ò ôa«› £ £ ÞL §@ » ¨á » ©‡
|
|||
|
|
» èkˆÂ¿ m ¢×Zú› Èà Î è Ï Î Ï È ©œ ”ò »œ Ÿò à ™ «› àÝZ „éò à «›¤õ› àú› ÷ò
|
|||
|
|
Í ¢×ZÝZú›«›ö ¢òþ «ò…‡ ‰‹ üÚø‹ üëôJ G Attempts to make a new `MappedRwLockReadGuard` for a component of theÁ üºõJ G locked data. Returns the original guard if the closure returns `None`.Á ‰öË ü‘ö>õð üÔö ½ñ øöË ü€÷3Ø ü¸÷U R used as `RwLockReadGuard::try_map(...)`. A method would interfere with methods ofÁ ü’ø5Ö™<áø ôa«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘‚ôôa Èà Ñ è Ò Ñ Ò È ©œ éø »œ ôø á ™ «› áÝZ ÄÌù á «›Ìú› ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> áú› TÚù
|
|||
|
|
Ð ¢×ZÝZú›«›ö ÷øþ €ùÉË ÍÏ ü΀´ ü¯üJ¶õ üþüMÛ¢ üÐý!²£ öýË üþý>õð üÁþ ½ñ åþË üíþ3Ø ü¥ÿ\ Y used as `RwLockReadGuard::try_map_or_err(...)`. A method would interfere with methods ofÁ ü†€5Ö™tÕ€ ôa«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘‚ôôaþ¦ Èà Ô è Õ ¯ Ö Ô Õ Ö È ©œ ä€ »œ ï€ Ì§ ò€ â ™ «› âÝZ Üæ� â «›ßÿ› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ âú› þ¦lô�
|
|||
|
|
Ó ¢×ZÝZú›«›þ¦ö þ€þ ��äæ èê ìî üƆR üÑ„C @ Temporarily unlocks the `RwLock` to execute the given function.Á ™…Ë ü¡…D¸© üê…5 2 references to the data protected by the `RwLock`.Á R|²†D͆€ ã ãôaï«ô« Èè Ø à Ù Ù Ø ß† È ¨¬ Ö† º¬ Ù† ̬lŠ‡ ଠ–‡
|
|||
|
|
× ¢×ZÝZï«ô«ö ܆þ ê†KM OQ üçˆI ¢ Û Ì Ü ™ Ý Ý Û Ü Ñ“ ðˆ â“ ‡‰ Î×Z lóˆ ’”ƒ‰ ±”“‰ôaÞßâ ìˆCE ÛJL ÛÜå� ü·‰6 3 Unlocks the `RwLock` using a fair unlock protocol.Á ò‰Ë üú‰J G By default, `RwLock` is unfair and allow the current thread to re-lockÁ üÉŠK H the `RwLock` before another has the chance to acquire the lock, even ifÁ ü™‹I F that thread has been blocked on the `RwLock` for a long time. This isÁ üç‹E B the default because it allows much higher throughput as it avoidsÁ ü±ŒM J forcing a context switch on every `RwLock` unlock. This can result in oneÁ üƒ�C @ thread acquiring a `RwLock` many more times than other threads.Á Ë�Ë üÓ�L©´ ü¤ŽLÿ´ üõŽI F using this method instead of dropping the `RwLockReadGuard` normally.Á R|Ñ�\ì�€ ôa Ú Ú
|
|||
|
|
Þ ¢×ZÝZö ø�üè“W ü²‘CÓ€ ú‘Ë ü‚’4 1 The `RwLock` is unlocked a fair unlock protocol.Á »’Ë üÃ’D¸© üŒ“5º� R|Ô“lï“€ ä äôaï«ô« Úè à à á à á †” Ú ¨¬ ý“ º¬ €” ̬l±” ଠ½”
|
|||
|
|
ß ¢×ZÝZï«ô«ö ƒ”þ ‘”KM OQ ÌΘ ü•–H E Temporarily yields the `RwLock` to a waiting thread if there is one.Á â–Ë üê–L�Ê ü»—L I by `read`, however it can be much more efficient in the case where thereÁ ÜŒ˜ªË R|º˜$Õ˜€ å åôa Ú Ý˜ Ú
|
|||
|
|
â ¢×ZÝZö Ú˜üø™O ¢ ä Ì å ™ æ å æ ä Ñ“ �š â“ ”š ±íL„š ’”�š ±” šôaçè í î è ý™EG äLN ä\Κ4Óš ã ã ÝZ¬ñš,ôš æ æôa æÝZ ã úš ã
|
|||
|
|
è ¢×ZÝZ$ûšü¾›N ¢ ê Ì ë ™ ì ë ê ì Ñ“ Ç› â“ Ú› ±íLÊ› ’”Ö› ±”æ›ô
|
|||
|
|
» ã/S!&”p ¢×Zú› ûà � è ‚ � ‚ û ©œ °Ë »œ »Ë ð ™ «› ðÝZ Ä†Ì ð «›½¢› ðú›4˜Ì
|
|||
|
|
€ ¢×ZÝZú›«›ö ¾Ëþ ÇË…‡ ‰‹ ü‰Ò” ü•ÎK H Attempts to make a new `MappedRwLockWriteGuard` for a component of theÁ üåÎL›× ¶ÏË ü¾Ï?§ž ü‚Ð ½ñ ¦ÐË ü®Ð3Ø üæÐV S used as `RwLockWriteGuard::try_map(...)`. A method would interfere with methods ofÁ üÁÑ5Ö™<�Ò ©c«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘›¡©c ûà „ è … „ … û ©œ ˜Ò »œ £Ò ñ ™ «› ñÝZ üüÒ ñ «›¡§› ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE> ñú›tŽÓ
|
|||
|
|
ƒ ¢×ZÝZú›«›ö ¦Òþ ¯ÒÊÌ ÎÐ üŽÚ½ üìÕKÏ¢ ü¼ÖMÛ¢ üŽ×!²£ ´×Ë ü¼×?§ž ü€Ø ½ñ ¤ØË ü¬Ø3Ø üäØ] Z used as `RwLockWriteGuard::try_map_or_err(...)`. A method would interfere with methods ofÁ üÆÙ5Ö™t•Ú ©c«›ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘›¡©cþ¦ ûà ‡ è ˆ ¯ ‰ ˆ ‰ ‡ û ©œ ¤Ú »œ ¯Ú ̧ ²Ú ò ™ «› òÝZ ü§Û# ò «›¶¬› ê³í³ î³Ò ï³ì ð³ ñ³“ò³ì äs{ ©¶‘ òú›þ¦Œ¹Û
|
|||
|
|
† ¢×ZÝZú›«›þ¦ö ¾Úþ ÏÚåç éë íï ü”àR üŸÞCÓ€ çÞË üïÞD¸© ü¸ß5º� R|€àD›à€ ó ó©cï«ô« ûè ‹ à Œ Œ ‹ à û ¨¬ ¤à º¬ §à ̬lØà ଠäà
|
|||
|
|
Š ¢×ZÝZï«ô«ö ªàþ ¸àKM OQ ü»âO ¢ Ž Ì � ™ � � Ž � Ñ“ Äâ â“ àâ Ó×Z ”Çâ ’”Üâ ±”ìâ©c‘ Àâ=? ŽDF Žüôå6 ü‘ãL I Atomically downgrades a write lock into a read lock without allowing anyÁ üâãA > writers to take exclusive access of the lock in the meantime.Á ¨äË ü°äI F Note that if there are any writers currently waiting to take the lockÁ üþäI F then other readers may not be able to acquire the lock even if it wasÁ |Ìå downgraded.Á R|àåLûå€ ©côa � �
|
|||
|
|
‘ ¢×ZÝZö …æüÎèV ¢ “ Ì ” ™ • • ” “ Ñ“ ×è â“ úè ë×Z ÌÚè ’”öè ±”†é©c– Óè=? “DF “üšìN ü«éX U Atomically downgrades a write lock into an upgradable read lock without allowing anyÁ üˆêA´± ÎêË üÖêI‹² ü¤ëIÞ² |òë°³ R|†ì¼¡ì€ ©c�d ’ ’
|
|||
|
|
– ¢×ZÝZö ¹ìü¤ïJ ¢ ˜ Ì ™ ™ š š ˜ ™ Ñ“ ï â“ Äï —…l°ï ’”Àï ±”Ðï©c›œŸ ©ï<> ˜CE ˜Ü¤ö üõï6û„ °ðË ü¸ðJÇ… ü‡ñK›† ü×ñIð† ü¥òEÇ üïòM’ˆ üÁóCéˆ ‰ôË ü‘ôL©´ üâôLÿ´ ü³õJ G using this method instead of dropping the `RwLockWriteGuard` normally.Á R|�ö\«ö€ ©c — —
|
|||
|
|
› ¢×ZÝZö ·öü¯úW üù÷CÓ€ ÁøË üÉø4¥‹ ‚ùË üŠùD¸© üÓù5º� R|›úl¶ú€ ô ô©cï«ô« —è � à ž ž � Íú — ¨¬ Äú º¬ Çú ̬løú ଠ„û
|
|||
|
|
œ ¢×ZÝZï«ô«ö Êúþ ØúKM OQ Ì¡ÿ üçüHë� ´ýË ü¼ýL�Ê ü�þM J by `write`, however it can be much more efficient in the case where thereÁ ÜßþªË R|�ÿ$¨ÿ€ õ õ©c — °ÿ —
|
|||
|
|
Ÿ ¢×ZÝZö ÿüÓ€P ¢ ¡ Ì ¢ ™ £ £ ¡ ¢ Ñ“ Ü€ â“ ï€ ±íL߀ ’”ë€ ±”û€©c¤¥ í î ¥ Ø€EG
|
|||
|
|
meantime.Á „âË üŒâI‹² üÚâIÞ² |¨ã°³ R|¼ãL×〠�dôa Ñ Ñ
|
|||
|
|
Õ ¢×ZÝZö áãüøêK üÁæY V First, atomically upgrades an upgradable read lock lock into an exclusive write lock,Á üŸç9þÑ ÝçË üåçT Q Then, calls the provided closure with an exclusive reference to the lock's data.Á ¾èË üÆèL I Finally, atomically downgrades the lock back to an upgradable read lock.Á ü—éA > The closure's return value is wrapped in `Some` and returned.Á ÝéË üåéH E This function only requires a mutable reference to the guard, unlikeÁ ü²ê- * `upgrade` which takes the guard by value.Á R|äêlÿê€ „ „ �d«›Ó? ÑÓ? × è Ø × Ø ¬ë Ñ ©âðç �ë »œ ’ë ƒ ™ «› ƒ ÝZ ¬•ë ƒ «›Õè› ðç §ë
|
|||
|
|
Ö ¢×ZÝZðç«›$±ëþ ·ëz| ~€ üáôW ü’ð\ Y First, tries to atomically upgrade an upgradable read lock into an exclusive write lock.Á óðË üûðM÷� ÍñË üÕñY V Otherwise, calls the provided closure with an exclusive reference to the lock's data,Á ü³òD A and finally downgrades the lock back to an upgradable read lock.Á üüòAàä ÂóË üÊóH·å ü—ô1 . `try_upgrade` which takes the guard by value.Á R|ÍôŒèô€ † † �d«›ø°ú°û°Ð ü° ý°�þ°ì H�ˈXêE>ðç ÑÓ? Ú è Û Û Ú ™õ Ñ ªè úô »œ ÿô … ™ «› … ÝZ ¬‚õ … «›Éî› ðç ”õ
|
|||
|
|
Ù ¢×ZÝZðç«›$žõþ ¤õz| ~€ üÆú[ ¢ Ý Ì Þ ™ ß Þ Ý ß Ñ“ Ïú â“ îú î×Z ¬Òú ’”êú ±”úú�dàá Ëú@B ÝGI Ýüµýx ü¨ûI F Tries to atomically upgrade an upgradable read lock into an exclusiveÁ üöû+ ( write lock, until a timeout is reached.Á ¦üË ü®üG©· üúü" the current guard is returned.Á R|¡ý|¼ý€ �d ×Z Ö„Ö Ü Ü
|
|||
|
|
à ¢×ZÝZö Õý™Ò<æýüÀƒy ü¥�Iîï üó�+Áð £‚Ë ü«‚G©· ü÷‚"�ñ R|¬ƒŒÇƒ€ �d ×Z ×„Ö Ü Ü
|
|||
|
|
á ¢×ZÝZö ⃙Ò<óƒü±‡{ ¢ ã Ì ä ™ å ã å ä Ñ“ º‡ â“ õ‡ Œð¬½‡ àµÌÕ‡ ’”ñ‡ ±”�ˆ�dæé ¶‡BD ãIK ãü¹�� ü³ˆIîï ü�‰+Áð ±‰Ë ü¹‰G©· ¼…Š `None` is returned.Á ¡ŠË ü©ŠYçé ü‡‹DÊê üЋAàä –ŒË üžŒH·å üëŒ5 2 `try_upgrade_for` which takes the guard by value.Á R|¥�¬À�€ ˆ ˆ �dØò«›«í âÓ? ç è è ç è þ� â ªè Ö� »œ Û� ‡ ™ «› ‡ ÝZ ¬Þ� ‡ «›ðø› ðç ð�
|
|||
|
|
æ ¢×ZÝZðç«›$ƒŽ™Ò<‘Žþ ¯Ž„† ˆŠ ü옑 üä“Iîï ü²”+Áð â”Ë üê”G©· ¼¶•³õ Ò•Ë üÚ•Yçé ü¸–DÊê ü�—Aàä Ç—Ë üÏ—H·å üœ˜7 4 `try_upgrade_until` which takes the guard by value.Á R|ؘ¼ó˜€ Š Š �dŠô«›«í âÓ? ê è ë ê ë ³™ â ªè ‹™ »œ �™ ‰ ™ «› ‰ ÝZ ¬“™ ‰ «›âü› ðç ¥™
|
|||
|
|
é ¢×ZÝZðç«›$¸™™Ò<Æ™þ 㙄† ˆŠ ü˜Ÿ` ¢ í Ì î ™ ï í î ï Ñ“ ¡Ÿ â“ »Ÿ “Í„¤Ÿ ’”·Ÿ ±”ÇŸ�dðñ í î ñ �ŸEG íLN í\ÿŸ4„ ì ì ÝZ¬¢ ,¥ ‹ ‹ �d ‹ ÝZ ì « ì
|
|||
|
|
ñ ¢×ZÝZ$¬ üï _ ¢ ó Ì ô ™ õ õ ó ô Ñ“ ø â“ ’¡ “Í„û ’”Ž¡ ±”ž¡�dö � ö ô >@ óEG ó”ã¡$æ¡ Œ Œ �d ò ë¡ ò
|
|||
|
|
ö
|
|||
|
|
ì‡
|
|||
|
|
½^HPbïA ×ZÝZ !õ< wéþ î ‚ÿ î ÿ î î w î ×ZÝZï«ô«ÐÏÝÏü¹ã7 üðßK H An RAII mutex guard returned by `MutexGuard::map`, which can point to aÁ ü¼à# subfield of the protected data.Á ààË üäàO L The main difference between `MappedMutexGuard` and `MutexGuard` is that theÁ ü´áK H former doesn't support temporarily unlocking and re-locking, since thatÁ ü€âP M could introduce soundness issues if the locked object is modified by anotherÁ \Ñâ thread.ÁÆ4ßâ…ˤçâäßâ üÝâ ,üýâ;·Ë ²E ¢ ð Ì ñ ™ ò ñ ò ð Ñ“ Ùã â“ æã ó“DÜã ’”T÷ã ±”ô™äœ[ ì2ò<âª}A óôõ ¿ÕãOQ SU N ÷ã ï ï ¢×Z d‡ä$‡ä ï ï Õ¹‚4™ä ï ï ‰ ‰ Š ˲ Ñ{ ·Ë…YÚš¯ü–¥J üª¢W T An RAII implementation of a "scoped lock" of a reentrant mutex. When this structureÁ ü‚£? < is dropped (falls out of scope), the lock will be unlocked.Á Â£Ë üÆ£NøÉ Ü•¤ `Deref` implementation.ÁÆ4³¤…ˤ»¤ä³¤ ü±¤ ,üѤD 4if unused the ReentrantMutex will immediately unlockÁ ÅE ¢ ÷ Ì ø ¥ ù ™ ú ú ø ù ÷ Ñ“ ¹¥ ìÌ Æ¥ ýÌ Ö¥ ó“D¼¥ ©Í\É¥ ’”üç¥$ ÉÍ
|
|||
|
|
è͹^ ÿ 9Ïî ûü úµ¥ce gi km ]<ç¥Ë ö ö ŠÑü‘¦)4‘¦Ë ö ö ‰ ‰ Š ˲ Ñ{ ·Ë…YÚ ¢�_ ÍX!õ< áéþ ý ‚ÿ ý ÿ ý ý á ý ×Zû^�_«›èãÐÏ ö ö ÖI ûç Ë ü‡
|
|||
|
|
Ë ÿ 9Ïî ×Zû^�_ !õ< êéþ þ ‚ÿ þ ÿ þ þ ê þ ×Zû^�_«›èãÐÏ’Ýü¶�P üÉýT Q An RAII mutex guard returned by `ReentrantMutexGuard::map`, which can point to aÁ üžþ#õÐ ÂþË üÆþa ^ The main difference between `MappedReentrantMutexGuard` and `ReentrantMutexGuard` is that theÁ ü¨ÿK‡Ò üôÿPÜÒ \Å€µÓÆ4Ó€…ˤۀäÓ€ üÑ€ ,üñ€DªØ
|
|||
|
|
ØE ¢ € Ì � ¥ ‚ ™ ƒ ƒ � ‚ € Ñ“ ß� ìÌ ì� ýÌ ü� ó“Dâ� ©Í\ï� ’”ü�‚ ÉÍ
|
|||
|
|
èÍÔÇ‚¶_ ówñkŒhÄð „…† Û�hj ln pr b �‚Ë ÿ ÿ ¢ á á „ ä® Ë å» Ë æÀ
|
|||
|
|
Ë çÕ Ë XÊ9WN<¶ ×Zû^ t³‚$³‚Ë ÿ ÿ �_ æ4Ç‚Ë ÿ ÿ ‰ ‰ Š ˲ Ñ{ ·Ë…YÚ™Üü©ë7 üöéH E RAII structure used to release the shared read access of a lock whenÁ d¿ê dropped.ÁÆ4Îê…ˤÖêäÎê üÌê ,üìê< ,if unused the RwLock will immediately unlockÁ ëE ¢ ˆ Ì ‰ ™ Š ‰ Š ˆ Ñ“ Èë â“ Öë ±íLËë ’”Äçë ±” ôa üUfÏÏHä ‹Œ íÄëJL NP I4çë» ‡ ‡ �ðü…ì,4…ì» ‡ ‡ ‰ ‰ Š ˲ Ñ{ ·Ë…YÚ ¢ÝZ û‰!õ< ×éþ � ‚ÿ � ÿ � � × � ×ZÝZï«ô«ÐÏ ‡ ‡ … ‹Æ% » Œ‡
|
|||
|
|
» üUfÏÏHä ×ZÝZ !õ< ßéþ Ž ‚ÿ Ž ÿ Ž Ž ß Ž ×ZÝZï«ô«ÐÏ€éü»Ä8 ü„ÃL I RAII structure used to release the exclusive write access of a lock whenÁ dÑãäÆ4àÅˤèÃäàà üÞà ,üþÃ<Øä þE ¢ � Ì ‘ ™ ’ ‘ � ’ Ñ“ ÛÄ â“ éÄ ±íLÞÄ ’”ÄúÄ ±” ©c ÷ŽÜs jh “” ¯×ÄJL NP I4úÄ» � � �ðü˜Å04˜Å» � � ‰ ‰ Š ˲ Ñ{ ·Ë…YÚš¯û‰!õ< Šéþ • ‚ÿ • ÿ • • Š • ×ZÝZï«ô«ÐÏ � � † “Æ% » ”‡
|
|||
|
|
» ÷ŽÜs jh ×ZÝZ ! õ< œéþ – ‚ÿ – ÿ – – œ – ×ZÝZï«ô«ÐÏÀîü°¼H üùºL I RAII structure used to release the upgradable read access of a lock whenÁ dÆ»£äÆ4Õ»…ˤݻäÕ» üÓ» ,üó»<Øä F ¢ ˜ Ì ™ ™ š š ˜ ™ Ñ“ Ù¼ â“ î¼ “ܼ̈́ ’”Äÿ¼ ±” �d 6Eô6óö ›œ öÕ¼JL NP I4ÿ¼» — — �ðü�½,4�½» — — áç! õ< Ãéþ � ‚ÿ � ÿ � � à � ×ZÝZï«ô«ÐÏ — — ÷K ›Æ% » œ‡
|
|||
|
|
» 6Eô6óö ×ZÝZ ! õ< Íéþ ž ‚ÿ ž ÿ ž ž Í ž ×ZÝZï«ô«ÐÏÕó! õ< Öéþ Ÿ ‚ÿ Ÿ ÿ Ÿ Ÿ Ö Ÿ ×ZÝZðç«›ÐÏÕó! õ< Ùéþ ‚ÿ ÿ Ù ×ZÝZðç«›ÐÏÕó!!õ< æéþ ¡ ‚ÿ ¡ ÿ ¡ ¡ æ ¡ ×ZÝZðç«›ÐÏÕó!"õ< ééþ ¢ ‚ÿ ¢ ÿ ¢ ¢ é ¢ ×ZÝZðç«›ÐÏÕóüšœ= ü½˜T Q An RAII read lock guard returned by `RwLockReadGuard::map`, which can point to aÁ ü’™#õÐ ¶™Ë üº™Y V The main difference between `MappedRwLockReadGuard` and `RwLockReadGuard` is that theÁ ü”šK‡Ò üàšPÜÒ \±›µÓÆ4¿›…ˤǛ俛 ü½› ,üÝ›<Øä $F ¢ ¤ Ì ¥ ™ ¦ ¥ ¤ ¦ Ñ“ ¿œ â“ Íœ ±íLÂœ ’”TÞœ ±”Ô‚�‘e èkˆÂ¿ m §¨© ¦»œOQ SU N Þœ» £ £ ¬Ötîœ$ £ £ ÝZ 4‚�» £ £ ‰ ‰ Š ˲ Ñ{ ·Ë…YÚ‰èüåÉ> ü„ÆV S An RAII write lock guard returned by `RwLockWriteGuard::map`, which can point to aÁ üÛÆ#õÐ ÿÆË üƒÇ[ X The main difference between `MappedRwLockWriteGuard` and `RwLockWriteGuard` is that theÁ üßÇK‡Ò ü«ÈPÜÒ \üȵÓÆ4ŠÉ…ˤ’ÉäŠÉ üˆÉ ,ü¨É<Øä 7F ¢ « Ì ¬ ™ ¬ « Ñ“ ‹Ê â“ ™Ê ±íLŽÊ ’”TªÊ ±”ôÌÊ›f ã/S!&”p ®¯° Û‡ÊOQ SU N ªÊ» ª ª ¬ÖdºÊ$ºÊ» ª ª Õ¹~4ÌÊ» ª ª éÖ|]d^¢` /aƒd9f i si"4s'ûu,x1dy6Îy;-|@~EåJh�O«ƒTà„Yà‡^ Šzdžzj ‰o Æ|uÚ|{;‹€ æ�‡ ¾”Ž Éœ•ž•šUœŸQ�¤qž©|Ÿ®} ³æ¡¸ õ»¿‰¼ÆX£Ë ýÒ×½Ù òêà Ãñç Çùî#¯ó/°ø0±ý’² ˜Š
|
|||
|
|
¬Šý³ ð‹ „Œ(F¹.=¾41¿:5À@öÁF\ÂLÃR±ÄXwÅ^PÆd)Çj¬ÑpéÔv0Ö|ׂ‹×ˆü׎}Ù”‡ÚšeÜ âݦ®ß¬õà²Bä¸ È—ÀÜ—ÈwåÎ ÀšÖÔšÞ]èä éì ÿ´ô ³½ü—ñ:õ=ö©÷èø�ú ·Ú(ËÚ0Aü6 ªÜ>¾ÜF �‰N ›�V Ę^@údùjl÷p �©x£©€Øõ† ˆ«Žœ«– ñœ{ð¢ˆï¨Øî®Cî´Gíº³ìÀ ìÆJêÌ„éÒãçØ7æÞ6ääâê©áðþàö”àüËÝÝPÛØÚ*Ø”× –Ö&ØÕ,óÔ2/Ó8€Ñ>ÌÏD ÏJbÍPøÌVýË\XËb3Àhî¾nÕ»t°¹zƒ·€¯µ†Ï´Œ&´’¹³˜Õ±žì¯¤®ªW¬°¸ª¶‹©¼È¦Â{¥È¿£Îx¢ÔG ÚHžàÁ›æzšìA˜ò–ø–”þ˜’P‘
|
|||
|
|
¨Ž Ýæñæ ‚í(¤Œ. ðò6 Óù> í�FLƒL@~R»|X“{^˜zd<yj žrÖžzçw€ š ˆ® �šÆ˜cvž �̦ ƒÓ® ®Û¶Ôm¼ÏfÂ�eÈedÎ_cÔdbÚaà í†è�‡ð³_ö ƈþÚˆ ^ J]ÀWtV œë&ãQ, ‰õ4ôN: å�BÛIH š™P÷GVGF\LEbðCh ¬¤pÀ¤x›B~ •¦†©¦Ž  ˪ž ݲ¦°6¬µ5²Y4¸ ÎÂÀâÂÈ3Î ¬ÄÖÀÄÞ ÉÑæ ¶Øî Øàö!'ü& %Ä# ©ò½ò o"$ ˆô,œô4-27BF_r�«îû€•›¡®³Ñ䌛þƒˆ˜�¤©®´ÈÚû�’—¾ÈÑÜ≗¹Ç„ exampleÁ Ë extension traitsÁ „ óË ê� û� Ë Ë "„ Ë ê� û� Ë - RawMutexTimed::try_lock_untilÁ ” Ì
|
|||
|
|
û ® RawMutex::unlockÁ è
|
|||
|
|
Ÿ Self::from_rawÁ � ° RawMutex::lockÁ RawMutex::try_lockÁ RawMutexTimed::try_lock_forÁ ÕŽ ” ® �� è
|
|||
|
|
û Ì
|