目录

类

class AtomicBool

public class AtomicBool

功能：提供 Bool 类型的原子操作相关函数。

[h2]init(Bool)

public init(val: Bool)

功能：构造一个封装 Bool 数据类型的原子类型 AtomicBool 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Bool, Bool)

public func compareAndSwap(old: Bool, new: Bool): Bool

功能：CAS（Compare and Swap）操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Bool, Bool, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: Bool, new: Bool, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func load()

public func load(): Bool

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Bool

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Bool)

public func store(val: Bool): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Bool, MemoryOrder)

public func store(val: Bool, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Bool)

public func swap(val: Bool): Bool

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Bool, MemoryOrder)

public func swap(val: Bool, memoryOrder!: MemoryOrder): Bool

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicInt16

public class AtomicInt16

功能：提供 Int16 类型的原子操作相关函数。

[h2]init(Int16)

public init(val: Int16)

功能：构造一个封装 Int16 数据类型的原子类型 AtomicInt16 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Int16, Int16)

public func compareAndSwap(old: Int16, new: Int16): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Int16, Int16, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: Int16, new: Int16, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(Int16)

public func fetchAdd(val: Int16): Int16

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(Int16, MemoryOrder)

public func fetchAdd(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(Int16)

public func fetchAnd(val: Int16): Int16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(Int16, MemoryOrder)

public func fetchAnd(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(Int16)

public func fetchOr(val: Int16): Int16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(Int16, MemoryOrder)

public func fetchOr(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(Int16)

public func fetchSub(val: Int16): Int16

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(Int16, MemoryOrder)

public func fetchSub(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(Int16)

public func fetchXor(val: Int16): Int16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(Int16, MemoryOrder)

public func fetchXor(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): Int16

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int16

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Int16)

public func store(val: Int16): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Int16, MemoryOrder)

public func store(val: Int16, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Int16)

public func swap(val: Int16): Int16

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Int16, MemoryOrder)

public func swap(val: Int16, memoryOrder!: MemoryOrder): Int16

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicInt32

public class AtomicInt32

功能：提供 Int32 类型的原子操作相关函数。

[h2]init(Int32)

public init(val: Int32)

功能：构造一个封装 Int32 数据类型的原子类型 AtomicInt32 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Int32, Int32)

public func compareAndSwap(old: Int32, new: Int32): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Int32, Int32, MemoryOrDer, MemoryOrder)

public func compareAndSwap(old: Int32, new: Int32, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(Int32)

public func fetchAdd(val: Int32): Int32

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(Int32, MemoryOrder)

public func fetchAdd(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(Int32)

public func fetchAnd(val: Int32): Int32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(Int32, MemoryOrder)

public func fetchAnd(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(Int32)

public func fetchOr(val: Int32): Int32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(Int32, MemoryOrder)

public func fetchOr(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(Int32)

public func fetchSub(val: Int32): Int32

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(Int32, MemoryOrder)

public func fetchSub(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(Int32)

public func fetchXor(val: Int32): Int32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(Int32, MemoryOrder)

public func fetchXor(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): Int32

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int32

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Int32)

public func store(val: Int32): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Int32, MemoryOrder)

public func store(val: Int32, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Int32)

public func swap(val: Int32): Int32

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Int32, MemoryOrder)

public func swap(val: Int32, memoryOrder!: MemoryOrder): Int32

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicInt64

public class AtomicInt64

功能：提供 Int64 类型的原子操作相关函数。

[h2]init(Int64)

public init(val: Int64)

功能：构造一个封装 Int64 数据类型的原子类型 AtomicInt64 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Int64, Int64)

public func compareAndSwap(old: Int64, new: Int64): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Int64, Int64, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: Int64, new: Int64, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(Int64)

public func fetchAdd(val: Int64): Int64

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(Int64, MemoryOrder)

public func fetchAdd(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(Int64)

public func fetchAnd(val: Int64): Int64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(Int64, MemoryOrder)

public func fetchAnd(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(Int64)

public func fetchOr(val: Int64): Int64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(Int64, MemoryOrder)

public func fetchOr(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(Int64)

public func fetchSub(val: Int64): Int64

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(Int64, MemoryOrder)

public func fetchSub(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(Int64)

public func fetchXor(val: Int64): Int64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(Int64, MemoryOrder)

public func fetchXor(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): Int64

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int64

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Int64)

public func store(val: Int64): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Int64, MemoryOrder)

public func store(val: Int64, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Int64)

public func swap(val: Int64): Int64

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Int64, MemoryOrder)

public func swap(val: Int64, memoryOrder!: MemoryOrder): Int64

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicInt8

public class AtomicInt8

功能：提供 Int8 类型的原子操作相关函数。

[h2]init(Int8)

public init(val: Int8)

功能：构造一个封装 Int8 数据类型的原子类型 AtomicInt8 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Int8, Int8)

public func compareAndSwap(old: Int8, new: Int8): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Int8, Int8, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: Int8, new: Int8, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(Int8)

public func fetchAdd(val: Int8): Int8

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(Int8, MemoryOrder)

public func fetchAdd(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(Int8)

public func fetchAnd(val: Int8): Int8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(Int8, MemoryOrder)

public func fetchAnd(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(Int8)

public func fetchOr(val: Int8): Int8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(Int8, MemoryOrder)

public func fetchOr(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(Int8)

public func fetchSub(val: Int8): Int8

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(Int8, MemoryOrder)

public func fetchSub(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(Int8)

public func fetchXor(val: Int8): Int8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(Int8, MemoryOrder)

public func fetchXor(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): Int8

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int8

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Int8)

public func store(val: Int8): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Int8, MemoryOrder)

public func store(val: Int8, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Int8)

public func swap(val: Int8): Int8

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Int8, MemoryOrder)

public func swap(val: Int8, memoryOrder!: MemoryOrder): Int8

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicOptionReference

public class AtomicOptionReference<T> where T <: Object

功能：提供引用类型原子操作相关函数。

该引用类型必须是 Object 的子类。

[h2]init()

public init()

功能：构造一个空的 AtomicOptionReference 实例。

[h2]init(Option<T>)

public init(val: Option<T>)

功能：构造一个封装 Option<T> 数据类型的原子类型 AtomicOptionReference 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(Option<T>, Option<T>)

public func compareAndSwap(old: Option<T>, new: Option<T>): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(Option<T>, Option<T>, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: Option<T>, new: Option<T>, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func load()

public func load(): Option<T>

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Option<T>

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(Option<T>)

public func store(val: Option<T>): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(Option<T>, MemoryOrder)

public func store(val: Option<T>, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(Option<T>)

public func swap(val: Option<T>): Option<T>

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(Option<T>, MemoryOrder)

public func swap(val: Option<T>, memoryOrder!: MemoryOrder): Option<T>

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicReference

public class AtomicReference<T> where T <: Object

功能：引用类型原子操作相关函数。

该引用类型必须是 Object 的子类。

[h2]init(T)

public init(val: T)

功能：构造一个封装 T 数据类型的原子类型 AtomicReference 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(T, T)

public func compareAndSwap(old: T, new: T): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(T, T, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: T, new: T, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func load()

public func load(): T

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): T

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(T)

public func store(val: T): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(T, MemoryOrder)

public func store(val: T, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(T)

public func swap(val: T): T

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(T, MemoryOrder)

public func swap(val: T, memoryOrder!: MemoryOrder): T

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicUInt16

public class AtomicUInt16

功能：提供 UInt16 类型的原子操作相关函数。

[h2]init(UInt16)

public init(val: UInt16)

功能：构造一个封装 UInt16 数据类型的原子类型 AtomicUInt16 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(UInt16, UInt16)

public func compareAndSwap(old: UInt16, new: UInt16): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(UInt16, UInt16, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: UInt16, new: UInt16, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(UInt16)

public func fetchAdd(val: UInt16): UInt16

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(UInt16, MemoryOrder)

public func fetchAdd(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(UInt16)

public func fetchAnd(val: UInt16): UInt16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(UInt16, MemoryOrder)

public func fetchAnd(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt16)

public func fetchOr(val: UInt16): UInt16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt16, MemoryOrder)

public func fetchOr(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt16)

public func fetchSub(val: UInt16): UInt16

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt16, MemoryOrder)

public func fetchSub(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt16)

public func fetchXor(val: UInt16): UInt16

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt16, MemoryOrder)

public func fetchXor(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): UInt16

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt16

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(UInt16)

public func store(val: UInt16): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(UInt16, MemoryOrder)

public func store(val: UInt16, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(UInt16)

public func swap(val: UInt16): UInt16

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(UInt16, MemoryOrder)

public func swap(val: UInt16, memoryOrder!: MemoryOrder): UInt16

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicUInt32

public class AtomicUInt32

功能：提供 UInt32 类型的原子操作相关函数。

[h2]init(UInt32)

public init(val: UInt32)

功能：构造一个封装 UInt32 数据类型的原子类型 AtomicUInt32 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(UInt32, UInt32)

public func compareAndSwap(old: UInt32, new: UInt32): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(UInt32, UInt32, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: UInt32, new: UInt32, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(UInt32)

public func fetchAdd(val: UInt32): UInt32

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(UInt32, MemoryOrder)

public func fetchAdd(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(UInt32)

public func fetchAnd(val: UInt32): UInt32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(UInt32, MemoryOrder)

public func fetchAnd(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt32)

public func fetchOr(val: UInt32): UInt32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt32, MemoryOrder)

public func fetchOr(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt32)

public func fetchSub(val: UInt32): UInt32

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt32, MemoryOrder)

public func fetchSub(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt32)

public func fetchXor(val: UInt32): UInt32

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt32, MemoryOrder)

public func fetchXor(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): UInt32

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt32

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(UInt32)

public func store(val: UInt32): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(UInt32, MemoryOrder)

public func store(val: UInt32, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(UInt32)

public func swap(val: UInt32): UInt32

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(UInt32, MemoryOrder)

public func swap(val: UInt32, memoryOrder!: MemoryOrder): UInt32

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicUInt64

public class AtomicUInt64

功能：提供 UInt64 类型的原子操作相关函数。

[h2]init(UInt64)

public init(val: UInt64)

功能：构造一个封装 UInt64 数据类型的原子类型 AtomicUInt64 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(UInt64, UInt64)

public func compareAndSwap(old: UInt64, new: UInt64): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(UInt64, UInt64, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: UInt64, new: UInt64, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(UInt64)

public func fetchAdd(val: UInt64): UInt64

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(UInt64, MemoryOrder)

public func fetchAdd(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(UInt64)

public func fetchAnd(val: UInt64): UInt64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(UInt64, MemoryOrder)

public func fetchAnd(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt64)

public func fetchOr(val: UInt64): UInt64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt64, MemoryOrder)

public func fetchOr(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt64)

public func fetchSub(val: UInt64): UInt64

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt64, MemoryOrder)

public func fetchSub(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt64)

public func fetchXor(val: UInt64): UInt64

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt64, MemoryOrder)

public func fetchXor(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): UInt64

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt64

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(UInt64)

public func store(val: UInt64): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(UInt64, MemoryOrder)

public func store(val: UInt64, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(UInt64)

public func swap(val: UInt64): UInt64

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(UInt64, MemoryOrder)

public func swap(val: UInt64, memoryOrder!: MemoryOrder): UInt64

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class AtomicUInt8

public class AtomicUInt8

功能：提供 UInt8 类型的原子操作相关函数。

[h2]init(UInt8)

public init(val: UInt8)

功能：构造一个封装 UInt8 数据类型的原子类型 AtomicUInt8 的实例，其内部数据初始值为入参 val 的值。

参数：

[h2]func compareAndSwap(UInt8, UInt8)

public func compareAndSwap(old: UInt8, new: UInt8): Bool

功能：CAS 操作，采用默认内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func compareAndSwap(UInt8, UInt8, MemoryOrder, MemoryOrder)

public func compareAndSwap(old: UInt8, new: UInt8, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool

功能：CAS 操作，成功时使用 successOrder 指定的内存排序方式，失败时则使用 failureOrder 指定的内存排序方式。

比较当前原子类型的值与参数 old 指定的值是否相等。若相等，写入参数 new 指定的值，返回 true；否则，不写入值，并返回 false。

参数：

返回值：

[h2]func fetchAdd(UInt8)

public func fetchAdd(val: UInt8): UInt8

功能：采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。

参数：

返回值：

[h2]func fetchAdd(UInt8, MemoryOrder)

public func fetchAdd(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作。将结果写入当前原子类型实例，并返回加法运算前的值。

参数：

返回值：

[h2]func fetchAnd(UInt8)

public func fetchAnd(val: UInt8): UInt8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchAnd(UInt8, MemoryOrder)

public func fetchAnd(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作。将结果写入当前原子类型实例，并返回与操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt8)

public func fetchOr(val: UInt8): UInt8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchOr(UInt8, MemoryOrder)

public func fetchOr(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作。将结果写入当前原子类型实例，并返回或操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt8)

public func fetchSub(val: UInt8): UInt8

功能：采用默认内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchSub(UInt8, MemoryOrder)

public func fetchSub(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：采用参数 memoryOrder 指定的内存排序方式，以原子类型的值为被减数，参数 val 为减数，做减操作。将结果写入当前原子类型实例，并返回减操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt8)

public func fetchXor(val: UInt8): UInt8

功能：采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func fetchXor(UInt8, MemoryOrder)

public func fetchXor(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作。将结果写入当前原子类型实例，并返回异或操作前的值。

参数：

返回值：

[h2]func load()

public func load(): UInt8

功能：读取操作，采用默认内存排序方式，读取原子类型的值。

返回值：

[h2]func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt8

功能：读取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。

参数：

返回值：

[h2]func store(UInt8)

public func store(val: UInt8): Unit

功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func store(UInt8, MemoryOrder)

public func store(val: UInt8, memoryOrder!: MemoryOrder): Unit

功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。

参数：

[h2]func swap(UInt8)

public func swap(val: UInt8): UInt8

功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

[h2]func swap(UInt8, MemoryOrder)

public func swap(val: UInt8, memoryOrder!: MemoryOrder): UInt8

功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。

参数：

返回值：

class Barrier

public class Barrier

功能：提供协调多个线程一起执行到某一个程序点的功能。

率先达到程序点的线程将进入阻塞状态，当所有线程都达到程序点后，才一起继续执行。

[h2]init(Int64)

public init(count: Int64)

功能：创建 Barrier 对象。

参数：

异常：

[h2]func wait(Duration)

public func wait(timeout!: Duration = Duration.Max): Unit

功能：线程进入 Barrier 等待点。

如果 Barrier 对象所有调用 wait 的次数（即进入等待点的线程数）等于初始值，那么唤醒所有等待的线程；如果调用 wait 方法次数仍小于初始值，那么当前线程进入阻塞状态直到被唤醒或者等待时间超过 timeout；如果调用 wait 次数已大于初始值，那么线程继续执行。

参数：

class Monitor

public class Monitor <: ReentrantMutex

功能：提供使线程阻塞并等待来自另一个线程的信号以恢复执行的功能。

这是一种利用共享变量进行线程同步的机制，当一些线程因等待共享变量的某个条件成立而挂起时，另一些线程改变共享的变量，使条件成立，

然后执行唤醒操作。这使得挂起的线程被唤醒后可以继续执行。

[h2]init()

public init()

功能：通过默认构造函数创建 Monitor。

[h2]func notify()

public func notify(): Unit

功能：唤醒一个等待在该 Montior 上的线程。

异常：

[h2]func notifyAll()

public func notifyAll(): Unit

功能：唤醒所有等待在该 Montior 上的线程。

异常：

[h2]func wait(Duration)

public func wait(timeout!: Duration = Duration.Max): Bool

功能：当前线程挂起，直到对应的 notify 函数被调用，或者挂起时间超过 timeout。

参数：

返回值：

异常：

class MultiConditionMonitor

public class MultiConditionMonitor <: ReentrantMutex

功能：提供对同一个互斥锁绑定多个条件变量的功能。

  • 该类应仅当在 Monitor 类不足以实现高级并发算法时被使用。
  • 初始化时，MultiConditionMonitor 没有与之相关的条件变量。
  • 每次调用 newCondition 将创建一个新的等待队列并与当前对象关联，并返回ConditionID类型实例作为唯一标识符。

[h2]init()

public init()

功能：通过默认构造函数创建 MultiConditionMonitor。

[h2]func newCondition()

public func newCondition(): ConditionID

功能：创建一个与该 Monitor 相关的 ConditionID，可能被用来实现 “单互斥体多等待队列” 的并发原语。

返回值：

异常：

[h2]func notify(ConditionID)

public func notify(condID: ConditionID): Unit

功能：唤醒等待在所指定的条件变量的线程（如果有）。

参数：

异常：

[h2]func notifyAll(ConditionID)

public func notifyAll(condID: ConditionID): Unit

功能：唤醒所有等待在所指定的条件变量的线程（如果有）。

参数：

异常：

[h2]func wait(ConditionID, Duration)

public func wait(condID: ConditionID, timeout!: Duration = Duration.Max): Bool

功能：当前线程挂起，直到对应的 notify 函数被调用。

参数：

返回值：

异常：

class ReentrantMutex

public open class ReentrantMutex <: IReentrantMutex

功能：提供可重入锁相关功能。

可重入互斥锁的作用是对临界区加以保护，使得任意时刻最多只有一个线程能够执行临界区的代码。

当一个线程试图获取一个已被其他线程持有的锁时，该线程会被阻塞，直到锁被释放，该线程才会被唤醒，可重入是指线程获取该锁后可再次获得该锁。

  • ReentrantMutex 是内置的互斥锁，开发者需要保证不继承它。
  • 在访问共享数据之前，必须尝试获取锁。
  • 处理完共享数据后，必须进行解锁，以便其他线程可以获得锁。

[h2]init()

public init()

功能：创建可重入互斥锁。

异常：

[h2]func lock()

public open func lock(): Unit

功能：锁定互斥体，如果互斥体已被锁定，则阻塞。

[h2]func tryLock()

public open func tryLock(): Bool

功能：尝试锁定互斥体。

返回值：

[h2]func unlock

public open func unlock(): Unit

功能：解锁互斥体。

如果互斥体被重复加锁了 N 次，那么需要调用 N 次该函数来完全解锁，一旦互斥体被完全解锁，如果有其他线程阻塞在此锁上，那么唤醒他们中的一个。

异常：

class ReentrantReadMutex

public class ReentrantReadMutex <: ReentrantMutex

功能：提供可重入读写锁中的读锁类型。

[h2]func lock()

public func lock(): Unit

功能：获取读锁。

  • 在公平模式下，如果没有其他线程持有或等待写锁，或是当前线程已持有读锁，则立即持有读锁；否则，当前线程进入等待状态。
  • 在非公平模式下，如果没有其他线程持有或等待写锁，则立即持有读锁；如果有其他线程持有写锁，当前线程进入等待状态；否则，线程是否能立即持有读锁不做保证。
  • 多个线程可以同时持有读锁并且一个线程可以重复多次持有读锁；如果一个线程持有写锁，那么它仍可以持有读锁。

[h2]func tryLock()

public func tryLock(): Bool

功能：尝试获取读锁。该方法获取读锁时并不遵循公平模式。

返回值：

[h2]func unlock()

public func unlock(): Unit

功能：释放读锁。如果一个线程多次持有读锁，那么仅当释放操作和获取操作数量相同时才释放读锁；如果读锁被释放并且存在线程等待写锁，那么唤醒其中一个线程。

异常：

class ReentrantReadWriteMutex

public class ReentrantReadWriteMutex

功能：提供可重入读写锁相关功能。

它和普通互斥锁的差异在于：读写锁同时携带两个互斥锁，分别为“读锁”以及“写锁”，并且它允许多个线程同时持有读锁。

读写锁的特殊性质说明：

[h2]prop readMutex

public prop readMutex: ReentrantReadMutex

功能：获取读锁。

类型：ReentrantReadMutex

[h2]prop writeMutex

public prop writeMutex: ReentrantWriteMutex

功能：获取写锁。

类型：ReentrantWriteMutex

[h2]init(ReadWriteMutexMode)

public init(mode!: ReadWriteMutexMode = ReadWriteMutexMode.Unfair)

功能：构造读写锁。

参数：

class ReentrantWriteMutex

public class ReentrantWriteMutex <: ReentrantMutex

功能：提供可重入读写锁中的写锁类型。

[h2]func lock()

public func lock(): Unit

功能：获取写锁。只允许唯一线程能够持有写锁，且该线程能多次重复持有写锁。如果存在其他线程持有写锁或是读锁，那么当前线程进入等待状态。

异常：

[h2]func tryLock()

public func tryLock(): Bool

功能：尝试获取写锁。该方法获取读锁时并不遵循公平模式。

返回值：

[h2]func unlock()

public func unlock(): Unit

功能：释放写锁。

  • 如果一个线程多次持有读锁，那么仅当释放操作和获取操作数量相同时才释放读锁；如果读锁被释放并且存在线程等待写锁，那么唤醒其中一个线程。
  • 在公平模式下，如果写锁被释放并且存在线程等待读锁，那么优先唤醒这些等待线程；如果没有线程等待读锁，但存在线程等待写锁，那么唤醒其中一个线程。
  • 在非公平模式下，如果写锁被释放，优先唤醒等待写锁的线程还是等待读锁的线程不做保证，交由具体实现决定。

异常：

class Semaphore

public class Semaphore

功能：提供信号量相关功能。

Semaphore 可以被视为携带计数器的 Monitor，常用于控制并发访问共享资源的线程数量。

[h2]prop count

public prop count: Int64

功能：返回当前内部计数器的值。

类型：Int64

[h2]init(Int64)

public init(count: Int64)

功能：创建一个 Semaphore 对象并初始化内部计数器的值。

参数：

异常：

[h2]func acquire(Int64)

public func acquire(amount!: Int64 = 1): Unit

功能：向 Semaphore 对象获取指定值。

如果当前计数器小于要求的数值，那么当前线程将被阻塞，直到获取满足数量的值后才被唤醒。

参数：

异常：

[h2]func release(Int64)

public func release(amount!: Int64 = 1): Unit

功能：向 Semaphore 对象释放指定值。

如果内部计数器在累加释放值后能够满足当前阻塞在 Semaphore 对象的线程，那么将得到满足的线程唤醒；内部计数器的值不会大于初始值，即如果计数器的值在累加后大于初始值，那么仍被设置为初始值。所有在调用 release 之前的操作都先发生于调用 acquire/tryAcquire 之后的操作。

参数：

返回值：

异常：

[h2]func tryAcquire(Int64)

public func tryAcquire(amount!: Int64 = 1): Bool

功能：尝试向 Semaphore 对象获取指定值。

该方法不会阻塞线程。如果有多个线程并发执行获取操作，则无法保证线程间的获取顺序。

参数：

返回值：

异常：

class SyncCounter

public class SyncCounter

功能：提供倒数计数器功能。

线程可以等待计数器变为零。

[h2]prop count

public prop count: Int64

功能：获取计数器的当前值。

类型：Int64

[h2]init(Int64)

public init(count: Int64)

功能：创建倒数计数器。

参数：

异常：

[h2]func dec()

public func dec(): Unit

功能：计数器减一。

如果计数器变为零，那么唤醒所有等待的线程；如果计数器已经为零，那么数值保持不变。

[h2]func waitUntilZero(Duration)

public func waitUntilZero(timeout!: Duration = Duration.Max): Unit

功能：当前线程等待直到计数器变为零，或等待时间超过 timeout。

参数：

class Timer

public class Timer <: Equatable<Timer> & Hashable

功能：提供定时器功能。

用于在指定时间点或指定时间间隔后，执行指定任务一次或多次。

  • Timer 隐式包含了 spawn 操作，即，每个 Timer 会创建一个线程用于执行该 Timer 关联的 Task。
  • 每个 Timer 只能在初始化时绑定一个 Task，初始化完成后，无法重置关联的 Task。
  • 只有关联 Task 执行完毕，或 使用 cancel 接口主动取消 Timer，Timer 的生命周期才会结束，之后才能被 GC 回收。换句话说，在 Timer 关联的 Task 执行完毕或 Timer 被主动取消前，Timer 实例均不会被 GC 回收，从而确保关联 Task 可以被正常执行。
  • 系统繁忙时，Task 的触发时间可能会被影响。Timer 不保证 Task 的触发时间一定准时。Timer 保证 Task 的触发时间小于等于当前时间。
  • Timer 不会主动捕获关联 Task 抛出的异常。只要 Task 有未被捕获的异常，Timer 就会失效。
  • Timer 通常按使用方式分为 一次性任务定时器 和 重复性任务定时器两种，一次性任务定时器 Task 只会执行一次，重复性任务定时器 Task 会按指定周期执行, 直到使用 cancel 接口主动取消 或者 达到 Timer 创建时指定的结束条件。

[h2]static func after(Duration, ()->?Duration)

public static func after(delay: Duration, task: () -> Option<Duration>): Timer

功能：初始化一个 Timer，关联的 Task 被调度执行的次数取决于它的返回值。如果定时器第一次触发的时间点小于当前时间，关联的 Task 会立刻被调度执行。如果关联 Task 的返回值为 Option.None，该 Timer 将会失效，并停止调度关联 Task。如果关联 Task 的返回值为 Option.Some(v) 且 v 大于 Duration.Zero，下次运行前的最小时间间隔将被设置为 v。否则，关联 Task 会立刻再次被调度执行。

参数：

返回值：

[h2]static func once(Duration, ()->Unit)

public static func once(delay: Duration, task: ()->Unit): Timer

功能：设置并启动一次性定时任务，返回控制这个任务的 Timer 对象实例。

参数:

返回值: Timer 对象实例。

示例:

import std.sync.{Timer, sleep}
import std.time.{Duration, MonoTime}

main() {
    let start = MonoTime.now()
    Timer.once(Duration.second) {=>
        println("Tick at: ${MonoTime.now() - start}")
    }

    sleep(Duration.second * 2)
    0
}

运行结果:

Tick at: 1s2ms74us551ns

[h2]static func repeat(Duration, Duration, ()->Unit, CatchupStyle)

public static func repeat(delay: Duration, interval: Duration, task: ()->Unit, style!: CatchupStyle = Burst): Timer

功能：设置并启动重复性定时任务，返回控制这个任务的 Timer 对象实例。

参数:

返回值: Timer 对象实例。

异常:

示例:

import std.sync.{Timer, sleep}
import std.time.{Duration, MonoTime}

main() {
    let start = MonoTime.now()
    let timer = Timer.repeat(Duration.second, Duration.second, {=>
        println("Tick at: ${MonoTime.now() - start}")
    })


    sleep(Duration.second * 5)
    timer.cancel()

    0
}

运行结果:

Tick at: 1s2ms72us188ns
Tick at: 2s4ms185us160ns
Tick at: 3s6ms275us464ns
Tick at: 4s8ms18us399ns
Tick at: 5s9ms621us394ns

[h2]static func repeatDuring(Duration, Duration, Duration, ()->Unit, CatchupStyle)

public static func repeatDuring(period: Duration, delay: Duration, interval: Duration, task: () -> Unit, style!: CatchupStyle = Burst): Timer

功能：设置并启动重复性定时任务，指定重复周期的最大持续时间，返回控制这个任务的 Timer 对象实例。

参数:

返回值: Timer 对象实例。

异常:

示例:

import std.sync.{Timer, sleep}
import std.time.{Duration, MonoTime}

main() {
    let start = MonoTime.now()
    Timer.repeatDuring(Duration.second * 5, Duration.second, Duration.second, {=>
        println("Tick at: ${MonoTime.now() - start}")
    })

    sleep(Duration.second * 7)
    0
}

运行结果:

Tick at: 1s2ms372us626ns
Tick at: 2s4ms714us879ns
Tick at: 3s6ms769us623ns
Tick at: 4s8ms780us235ns
Tick at: 5s660us104ns
Tick at: 6s3ms257us508ns

[h2]static func repeatTimes(Int64, Duration, Duration, ()->Unit, CatchupStyle)

public static func repeatTimes(count: Int64, delay: Duration, interval: Duration, task: () -> Unit, style!: CatchupStyle = Burst): Timer

功能：设置并启动重复性定时任务，指定 Task 最大执行次数，返回控制这个任务的 Timer 对象实例。

参数:

返回值: Timer 对象实例。

异常:

示例:

import std.sync.{Timer, sleep}
import std.time.{Duration, MonoTime}

main() {
    let start = MonoTime.now()
    Timer.repeatTimes(3, Duration.second, Duration.second, {=>
        println("Tick at: ${MonoTime.now() - start}")
    })

    sleep(Duration.second * 4)
    0
}

运行结果:

Tick at: 1s2ms855us251ns
Tick at: 2s5ms390us18ns
Tick at: 3s7ms935us552ns

[h2]func cancel()

public func cancel(): Unit

功能：取消该 Timer，关联 Task 将不再被调度执行。

如果调用该函数时关联 Task 正在执行，不会打断当前运行。该函数不会阻塞当前线程。调用该函数多次等同于只调用一次。

[h2]func hashCode()

public func hashCode(): Int64

功能：获取 Timer 对象的哈希值。

返回值: Timer 对象的哈希值。

[h2]operator func !=(Timer)

public operator func !=(rhs: Timer): Bool

功能：判断当前 Timer 与入参 rhs 指定的 Timer 是否不是同一个实例。

返回值：

[h2]operator func ==(Timer)

public operator func ==(rhs: Timer): Bool

功能：判断当前 Timer 与入参 rhs 指定的 Timer 是否是同一个实例。

返回值：