tag | f549261c95698d7b190660b70d142ee0c38e76ae | |
---|---|---|
tagger | The Android Open Source Project <initial-contribution@android.com> | Fri Jan 28 19:16:12 2022 -0800 |
object | 46303a78f20e28e8c381dfa18132a87863e0895b |
Android Mainline 12.0.0 Release 21 (7967248,com.google.android.adbd)
commit | 46303a78f20e28e8c381dfa18132a87863e0895b | [log] [tgz] |
---|---|---|
author | Joel Galenson <jgalenson@google.com> | Wed Apr 28 22:32:41 2021 +0000 |
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | Wed Apr 28 22:32:41 2021 +0000 |
tree | 8aa33bfe69d31d520c9f1aa0b31ed2e4683f5595 | |
parent | 3c43a6308d8e883ead9859cd9a4df6963b949539 [diff] | |
parent | 0508ccd77663713347040e849ad3e1fc97bf495d [diff] |
Generate apex_available from c2a instead of a patch am: d00e1ff9c4 am: f5d829f250 am: caf840c5c9 am: 0508ccd776 Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/spin/+/1689918 Change-Id: Ic83041bd10ab6efa87bfa948a8672e1e8432a54a
Spin-based synchronization primitives.
This crate provides spin-based versions of the primitives in std::sync
. Because synchronization is done through spinning, the primitives are suitable for use in no_std
environments.
Before deciding to use spin
, we recommend reading this superb blog post by @matklad that discusses the pros and cons of spinlocks. If you have access to std
, it's likely that the primitives in std::sync
will serve you better except in very specific circumstances.
Mutex
, RwLock
and Once
equivalentsno_std
environmentslock_api
compatibilityRwLock
guardsstd
feature to enable yield to the OS scheduler in busy loopsMutex
can become a ticket lockInclude the following under the [dependencies]
section in your Cargo.toml
file.
spin = "x.y"
When calling lock
on a Mutex
you will get a guard value that provides access to the data. When this guard is dropped, the lock will be unlocked.
extern crate spin; use std::{sync::Arc, thread}; fn main() { let counter = Arc::new(spin::Mutex::new(0)); let thread = thread::spawn({ let counter = counter.clone(); move || { for _ in 0..10 { *counter.lock() += 1; } } }); for _ in 0..10 { *counter.lock() += 1; } thread.join().unwrap(); assert_eq!(*counter.lock(), 20); }
The crate comes with a few feature flags that you may wish to use.
lock_api
enabled support for lock_api
ticket_mutex
uses a ticket lock for the implementation of Mutex
std
enables support for thread yielding instead of spinning
It is often desirable to have a lock shared between threads. Wrapping the lock in an std::sync::Arc
is route through which this might be achieved.
Locks provide zero-overhead access to their data when accessed through a mutable reference by using their get_mut
methods.
The behaviour of these lock is similar to their namesakes in std::sync
. they differ on the following:
spin
is distributed under the MIT License, (See LICENSE
).