Module work

Work management, concurrency handling.
work

Extends: std::{future, process, sync, task, thread}

---

Macros

• sleep4std
  A more compact Thread::sleep.
• task_ready
  core Extracts the successful type of a TaskPoll<T>.
• thread_localstd
  std Declare a new thread local storage key of type ThreadLocalKey.

Structs

• Arcalloc
  alloc A thread-safe reference-counting pointer.
• ArcWeakalloc
  alloc A version of Arc that holds a non-owning reference to the managed allocation.
• Atomicdep_atomic
  ⚛️ atomic A generic atomic wrapper type.
• AtomicBool
  ⚛️ ?core A boolean type which can be safely shared between threads.
• AtomicF32dep_portable_atomic
  ⚛️ portable-atomic A floating point type which can be safely shared between threads.
• AtomicF64dep_portable_atomic
  ⚛️ portable-atomic A floating point type which can be safely shared between threads.
• AtomicI8
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI16
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI32
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI64
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicI128dep_portable_atomic
  ⚛️ portable-atomic A signed integer type which can be safely shared between threads.
• AtomicIsize
  ⚛️ ?core A signed integer type which can be safely shared between threads.
• AtomicPtr
  ⚛️ ?core A raw pointer type which can be safely shared between threads.
• AtomicU8
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU16
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU32
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU64
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• AtomicU128dep_portable_atomic
  ⚛️ portable-atomic An unsigned integer type which can be safely shared between threads.
• AtomicUsize
  ⚛️ ?core An unsigned integer type which can be safely shared between threads.
• Barrierstd
  std Enables multiple threads to synchronize the beginning of some computation.
• BarrierWaitResultstd
  std Returned by Barrier::wait() when all threads in the Barrier have rendezvoused.
• Condvarstd
  std A Condition Variable
• Corounsafe_async
  Represents a single thread stackless coroutine.
• CoroRununsafe_async and alloc
  A managed dynamic collection of single-thread Coroutines.
• CoroYieldunsafe_async
  A future that alternates between Ready and Pending status each time it’s polled.
• FuturePending
  core A future which never resolves, representing a computation that never finishes.
• FuturePollFn
  core A Future that wraps a function returning TaskPoll.
• FutureReady
  core A future that is immediately ready with a value.
• Mutexstd
  std A mutual exclusion primitive useful for protecting shared data
• MutexGuardstd
  std An RAII implementation of a “scoped lock” of a mutex.
• Oncestd
  std A synchronization primitive which can be used to run a one-time global initialization.
• OnceLockstd
  std A synchronization primitive which can be written to only once.
• OnceStatestd
  std State yielded to Once::call_once_force()’s closure parameter.
• PoisonErrorstd
  🚩 std A type of error which can be returned whenever a lock is acquired.
• RwLockstd
  std A reader-writer lock
• RwLockReadGuardstd
  std RAII structure used to release the shared read access of a lock when dropped.
• RwLockWriteGuardstd
  std RAII structure used to release the exclusive write access of a lock when dropped.
• TaskContext
  core The context of an asynchronous task.
• TaskRawWaker
  core Allows the implementor of a task executor to create a TaskWaker.
• TaskRawWakerVTable
  core A virtual function pointer table that specifies the behavior of a TaskRawWaker.
• TaskWaker
  core A handle for waking up a task by notifying its executor that it is ready to be run.
• Threadstd
  std A handle to a thread.
• ThreadAccessErrorstd
  std An error returned by ThreadLocalKey::try_with.
• ThreadBuilderstd
  std Thread factory, which can be used in order to configure the properties of a new thread.
• ThreadIdstd
  std A unique identifier for a running thread.
• ThreadJoinHandlestd
  std An owned permission to join on a thread (block on its termination).
• ThreadLocalKeystd
  std A thread local storage key which owns its contents.
• ThreadScopestd
  std A scope to spawn scoped threads in.
• ThreadScopedJoinHandlestd
  std An owned permission to join on a scoped thread (block on its termination).
• WaitTimeoutResultstd
  std A type indicating whether a timed wait on a condition variable returned due to a time out or not.

Enums

• AtomicOrdering
  core Atomic memory ordering.
• TaskPoll
  core Indicates whether a value is ready or if the current task is still pending.
• TryLockErrorstd
  🚩+ std An enumeration of possible errors associated with a TryLockResult.
• CoroutineStateExperimentalnightly_coro
  core The result of a coroutine resumption.

Traits

• ExtFuture
  Extension trait providing additional methods for Futures.
• ExtThread
  Extension trait providing additional methods for Threads.
• Future
  core An asynchronous computation obtained by use of async.
• IntoFuture
  core Conversion into a Future.
• TaskWakealloc
  alloc The implementation of waking a task on an executor.
• CoroutineExperimentalnightly_coro
  core The trait implemented by builtin coroutine types.

Functions

• atomic_compiler_fence
  core A compiler memory fence.
• atomic_fence
  core An atomic fence.
• future_blockstd
  Blocks the thread until the future is ready.
• future_pending
  core Creates a FuturePending future.
• future_ready
  core Creates a FutureReady.
• task_waker_noopunsafe_async
  Creates a new Waker that does nothing when wake is called.

Type Aliases

• LockResultstd
  std A type alias for the result of a lock method which can be poisoned.
• ThreadResultstd
  ⚖️ std A specialized Result type for threads.
• TryLockResultstd
  ⚖️ std A type alias for the result of a nonblocking locking method.