Caution

You’re reading a draft of the Ferrocene Language Specification. Some parts of this document might be missing, incomplete or incorrect. Our aim is to have the specification ready by the end of 2022.

17. Concurrency

17:1 The Rust programming language provides features for concurrent programming without data races, whose rules are presented in this chapter.

Legality Rules

17:2 A data race is a scenario where two or more threads access a shared memory location concurrently without any synchronization, where one of the accesses is a modification.

Undefined Behavior

17:3 It is undefined behavior if two or more threads engage in a data race.

17.1. Send and Sync

Legality Rules

17.1:1 The Rust programming language provides synchronization facilities for types through the core::marker::Send trait and the core::marker::Sync trait.

17.1:2 A send type is a type that implements the core::marker::Send trait.

17.1:3 An abstract data type automatically implements the core::marker::Send trait if the types of all its fields are send types.

17.1:4 A send type shall have values that are safe to transfer across thread boundaries.

17.1:5 A sync type is a type that implements the core::marker::Sync trait.

17.1:6 An abstract data type automatically implements the core::marker::Sync trait if the types of all its fields are sync types.

17.1:7 A sync type shall have references that are safe to transfer across thread boundaries.

17.2. Atomics

Legality Rules

17.2:1 An atomic type is a type defined in module core::sync::atomic. Atomic types provide primitive shared-memory communication between threads.

17.2:2 Atomic types are related to types as follows:

17.2:3

Type

Atomic Type

17.2:4

bool

core::sync::atomic::AtomicBool

17.2:5

i8

core::sync::atomic::AtomicI8

17.2:6

i16

core::sync::atomic::AtomicI16

17.2:7

i32

core::sync::atomic::AtomicI32

17.2:8

i64

core::sync::atomic::AtomicI64

17.2:9

isize

core::sync::atomic::AtomicIsize

17.2:10

*mut T

core::sync::atomic::AtomicPtr

17.2:11

u8

core::sync::atomic::AtomicU8

17.2:12

u16

core::sync::atomic::AtomicU16

17.2:13

u32

core::sync::atomic::AtomicU32

17.2:14

u64

core::sync::atomic::AtomicU64

17.2:15

usize

core::sync::atomic::AtomicUsize

17.3. Asynchronous Computation

Legality Rules

17.3:1 The Rust programming language provides asynchronous computation through module core::task and the core::future::Future trait.

17.3:2 A future represents a value of a type that implements the core::future::Future trait which may not have finished computing yet.

17.3:3 The computed value of a future is obtained by using an await expression or by invoking core::future::Future::poll.

17.3:4 core::future::Future::poll shall not be invoked on a future that has already returned core::task::Poll::Ready.