# Struct ethcore_util::standard::MutexGuard [−]

    #[must_use]
    pub struct MutexGuard<'a, T> where T: 'a + ?Sized { /* fields omitted */ }

An RAII implementation of a "scoped lock" of a mutex. When this structure is dropped (falls out of scope), the lock will be unlocked.

The data protected by the mutex can be accessed through this guard via its `Deref` and `DerefMut` implementations.

## Methods

### `impl<'a, T> MutexGuard<'a, T> where T: 'a + ?Sized`

#### `fn unlock_fair(self)`

Unlocks the mutex using a fair unlock protocol.

By default, mutexes are unfair and allow the current thread to re-lock the mutex before another has the chance to acquire the lock, even if that thread has been blocked on the mutex for a long time. This is the default because it allows much higher throughput as it avoids forcing a context switch on every mutex unlock. This can result in one thread acquiring a mutex many more times than other threads.

However in some cases it can be beneficial to ensure fairness by forcing the lock to pass on to a waiting thread if there is one. This is done by using this method instead of dropping the `MutexGuard` normally.

## Trait Implementations

### `impl<'a, T> Deref for MutexGuard<'a, T> where T: 'a + ?Sized`

#### `type Target = T`

The resulting type after dereferencing

#### `fn deref(&self) -> &T`

The method called to dereference a value

### `impl<'a, T> Drop for MutexGuard<'a, T> where T: 'a + ?Sized`

#### `fn drop(&mut self)`

A method called when the value goes out of scope. Read more

### `impl<'a, T> StableAddress for MutexGuard<'a, T> where T: ?Sized`

### `impl<'a, T> DerefMut for MutexGuard<'a, T> where T: 'a + ?Sized`

#### `fn deref_mut(&mut self) -> &mut T`

The method called to mutably dereference a value

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)