# RwLock in spin::rw_lock - Rust
A lock that provides data access to either one writer or many readers.
Keywords: rust, rustlang, rust-lang, RwLock

# Struct spin::rw_lock::RwLock

source · [−]

    pub struct RwLock<T: ?Sized> { /* private fields */ }

Expand description

A lock that provides data access to either one writer or many readers.

This lock behaves in a similar manner to its namesake `std::sync::RwLock` but uses spinning for synchronisation instead. Unlike its namespace, this lock does not track lock poisoning.

This type of lock allows a number of readers or at most one writer at any point in time. The write portion of this lock typically allows modification of the underlying data (exclusive access) and the read portion of this lock typically allows for read-only access (shared access).

The type parameter `T` represents the data that this lock protects. It is required that `T` satisfies `Send` to be shared across tasks and `Sync` to allow concurrent access through readers. The RAII guards returned from the locking methods implement `Deref` (and `DerefMut` for the `write` methods) to allow access to the contained of the lock.

An `RwLockUpgradableGuard` can be upgraded to a writable guard through the `RwLockUpgradableGuard::upgrade` `RwLockUpgradableGuard::try_upgrade` functions. Writable or upgradeable guards can be downgraded through their respective `downgrade` functions.

Based on Facebook’s `folly/RWSpinLock.h`. This implementation is unfair to writers - if the lock always has readers, then no writers will ever get a chance. Using an upgradeable lock guard can somewhat alleviate this issue as no new readers are allowed when an upgradeable guard is held, but upgradeable guards can be taken when there are existing readers. However if the lock is that highly contended and writes are crucial then this implementation may be a poor choice.

## Examples

    use spin;

    let lock = spin::RwLock::new(5);

    // many reader locks can be held at once
    {
        let r1 = lock.read();
        let r2 = lock.read();
        assert_eq!(*r1, 5);
        assert_eq!(*r2, 5);
    } // read locks are dropped at this point

    // only one write lock may be held, however
    {
        let mut w = lock.write();
        *w += 1;
        assert_eq!(*w, 6);
    } // write lock is dropped here

## Implementations

source

### impl<T> RwLock<T>

source

#### pub const fn new(user_data: T) -> RwLock<T>

Creates a new spinlock wrapping the supplied data.

May be used statically:

    use spin;

    static RW_LOCK: spin::RwLock<()> = spin::RwLock::new(());

    fn demo() {
        let lock = RW_LOCK.read();
        // do something with lock
        drop(lock);
    }

source

#### pub fn into_inner(self) -> T

Consumes this `RwLock`, returning the underlying data.

source

### impl<T: ?Sized> RwLock<T>

source

#### pub fn read(&self) -> RwLockReadGuard<'_, T>

Locks this rwlock with shared read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers which hold the lock. There may be other readers currently inside the lock when this method returns. This method does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

Returns an RAII guard which will release this thread’s shared access once it is dropped.

    let mylock = spin::RwLock::new(0);
    {
        let mut data = mylock.read();
        // The lock is now locked and the data can be read
        println!("{}", *data);
        // The lock is dropped
    }

source

#### pub fn try_read(&self) -> Option<RwLockReadGuard<'_, T>>

Attempt to acquire this lock with shared read access.

This function will never block and will return immediately if `read` would otherwise succeed. Returns `Some` of an RAII guard which will release the shared access of this thread when dropped, or `None` if the access could not be granted. This method does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

    let mylock = spin::RwLock::new(0);
    {
        match mylock.try_read() {
            Some(data) => {
                // The lock is now locked and the data can be read
                println!("{}", *data);
                // The lock is dropped
            },
            None => (), // no cigar
        };
    }

source

#### pub fn reader_count(&self) -> usize

Return the number of readers that currently hold the lock (including upgradable readers).

##### Safety

This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.

source

#### pub fn writer_count(&self) -> usize

Return the number of writers that currently hold the lock.

Because `RwLock` guarantees exclusive mutable access, this function may only return either `0` or `1`.

##### Safety

This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.

source

#### pub unsafe fn force_read_decrement(&self)

Force decrement the reader count.

##### Safety

This is extremely unsafe if there are outstanding `RwLockReadGuard`s live, or if called more times than `read` has been called, but can be useful in FFI contexts where the caller doesn’t know how to deal with RAII. The underlying atomic operation uses `Ordering::Release`.

source

#### pub unsafe fn force_write_unlock(&self)

Force unlock exclusive write access.

##### Safety

This is extremely unsafe if there are outstanding `RwLockWriteGuard`s live, or if called when there are current readers, but can be useful in FFI contexts where the caller doesn’t know how to deal with RAII. The underlying atomic operation uses `Ordering::Release`.

source

#### pub fn write(&self) -> RwLockWriteGuard<'_, T>

Lock this rwlock with exclusive write access, blocking the current thread until it can be acquired.

This function will not return while other writers or other readers currently have access to the lock.

Returns an RAII guard which will drop the write access of this rwlock when dropped.

    let mylock = spin::RwLock::new(0);
    {
        let mut data = mylock.write();
        // The lock is now locked and the data can be written
        *data += 1;
        // The lock is dropped
    }

source

#### pub fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>>

Attempt to lock this rwlock with exclusive write access.

This function does not ever block, and it will return `None` if a call to `write` would otherwise block. If successful, an RAII guard is returned.

    let mylock = spin::RwLock::new(0);
    {
        match mylock.try_write() {
            Some(mut data) => {
                // The lock is now locked and the data can be written
                *data += 1;
                // The lock is implicitly dropped
            },
            None => (), // no cigar
        };
    }

source

#### pub fn upgradeable_read(&self) -> RwLockUpgradableGuard<'_, T>

Obtain a readable lock guard that can later be upgraded to a writable lock guard. Upgrades can be done through the `RwLockUpgradableGuard::upgrade` method.

source

#### pub fn try_upgradeable_read(&self) -> Option<RwLockUpgradableGuard<'_, T>>

Tries to obtain an upgradeable lock guard.

source

#### pub fn get_mut(&mut self) -> &mut T

Returns a mutable reference to the underlying data.

Since this call borrows the `RwLock` mutably, no actual locking needs to take place – the mutable borrow statically guarantees no locks exist.

##### Examples

    let mut lock = spin::RwLock::new(0);
    *lock.get_mut() = 10;
    assert_eq!(*lock.read(), 10);

## Trait Implementations

source

### impl<T: ?Sized + Debug> Debug for RwLock<T>

source

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

source

### impl<T: ?Sized + Default> Default for RwLock<T>

source

#### fn default() -> RwLock<T>

Returns the “default value” for a type. Read more

source

### impl<T> From<T> for RwLock<T>

source

#### fn from(data: T) -> Self

Converts to this type from the input type.

source

### impl<T: ?Sized + Send> Send for RwLock<T>

source

### impl<T: ?Sized + Send + Sync> Sync for RwLock<T>

## Auto Trait Implementations

### impl<T> !RefUnwindSafe for RwLock<T>

### impl<T: ?Sized> Unpin for RwLock<T> where
T: Unpin,

### impl<T: ?Sized> UnwindSafe for RwLock<T> where
T: UnwindSafe,

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<!> for T

const: unstable · source

#### fn from(t: !) -> T

Converts to this type from the input type.

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.