Module std::sync [] [src]

Useful synchronization primitives

This module contains useful safe and unsafe synchronization primitives. Most of the primitives in this module do not provide any sort of locking and/or blocking at all, but rather provide the necessary tools to build other types of concurrent primitives.

Modules

atomic

Atomic types

mpsc

Multi-producer, single-consumer FIFO queue communication primitives.

Structs

Arc

An atomically reference counted wrapper for shared state.

Barrier

A barrier enables multiple threads to synchronize the beginning of some computation.

BarrierWaitResult

A result returned from wait.

Condvar

A Condition Variable

Mutex

A mutual exclusion primitive useful for protecting shared data

MutexGuard

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

Once

A synchronization primitive which can be used to run a one-time global initialization. Useful for one-time initialization for FFI or related functionality. This type can only be constructed with the ONCE_INIT value.

PoisonError

A type of error which can be returned whenever a lock is acquired.

RwLock

A reader-writer lock

RwLockReadGuard

RAII structure used to release the shared read access of a lock when dropped.

RwLockWriteGuard

RAII structure used to release the exclusive write access of a lock when dropped.

Future [Deprecated]

A type encapsulating the result of a computation which may not be complete

Semaphore [Unstable]

A counting, blocking, semaphore.

SemaphoreGuard [Unstable]

An RAII guard which will release a resource acquired from a semaphore when dropped.

StaticCondvar [Unstable]

Statically allocated condition variables.

StaticMutex [Unstable]

The static mutex type is provided to allow for static allocation of mutexes.

StaticRwLock [Unstable]

Structure representing a statically allocated RwLock.

Weak [Unstable]

A weak pointer to an Arc.

Enums

TryLockError

An enumeration of possible errors which can occur while calling the try_lock method.

Constants

ONCE_INIT

Initialization value for static Once values.

CONDVAR_INIT [Unstable]

Constant initializer for a statically allocated condition variable.

MUTEX_INIT [Unstable]

Static initialization of a mutex. This constant can be used to initialize other mutex constants.

RW_LOCK_INIT [Unstable]

Constant initialization for a statically-initialized rwlock.

Type Definitions

LockResult

A type alias for the result of a lock method which can be poisoned.

TryLockResult

A type alias for the result of a nonblocking locking method.