类

class AtomicBool

public class AtomicBool

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

init(Bool)

public init(val: Bool)

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

参数：

val: Bool - 原子类型的初始值。

func compareAndSwap(Bool, Bool)

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

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

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

参数：

old: Bool - 与当前原子类型进行比较的值。
new: Bool - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: Bool - 与当前原子类型进行比较的值。
new: Bool - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func load()

public func load(): Bool

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

返回值：

Bool - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Bool

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Bool - 当前原子类型的值。

func store(Bool)

public func store(val: Bool): Unit

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

参数：

val: Bool - 写入原子类型的值。

func store(Bool, MemoryOrder)

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

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

参数：

val: Bool - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Bool)

public func swap(val: Bool): Bool

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

参数：

val: Bool - 写入原子类型的值。

返回值：

Bool - 写入前的值。

func swap(Bool, MemoryOrder)

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

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

参数：

val: Bool - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Bool - 写入前的值。

class AtomicInt16

public class AtomicInt16

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

init(Int16)

public init(val: Int16)

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

参数：

val: Int16 - 原子类型的初始值。

func compareAndSwap(Int16, Int16)

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

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

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

参数：

old: Int16 - 与当前原子类型进行比较的值。
new: Int16 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false

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。

参数：

old: Int16 - 与当前原子类型进行比较的值。
new: Int16 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(Int16)

public func fetchAdd(val: Int16): Int16

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

参数：

val: Int16 - 与原子类型进行加操作的值。

返回值：

Int16 - 执行加操作前的值。

func fetchAdd(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 执行加操作前的值。

func fetchAnd(Int16)

public func fetchAnd(val: Int16): Int16

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

参数：

val: Int16 - 与原子类型进行与操作的值。

返回值：

Int16 - 执行与操作前的值。

func fetchAnd(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 执行与操作前的值。

func fetchOr(Int16)

public func fetchOr(val: Int16): Int16

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

参数：

val: Int16 - 与原子类型进行或操作的值。

返回值：

Int16 - 执行或操作前的值。

func fetchOr(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 执行或操作前的值。

func fetchSub(Int16)

public func fetchSub(val: Int16): Int16

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

参数：

val: Int16 - 与原子类型进行减操作的值。

返回值：

Int16 - 执行减操作前的值。

func fetchSub(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 执行减操作前的值。

func fetchXor(Int16)

public func fetchXor(val: Int16): Int16

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

参数：

val: Int16 - 与原子类型进行异或操作的值。

返回值：

Int16 - 执行异或操作前的值。

func fetchXor(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 执行异或操作前的值。

func load()

public func load(): Int16

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

返回值：

Int16 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int16

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 当前原子类型的值。

func store(Int16)

public func store(val: Int16): Unit

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

参数：

val: Int16 - 写入原子类型的值。

func store(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Int16)

public func swap(val: Int16): Int16

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

参数：

val: Int16 - 写入原子类型的值。

返回值：

Int16 - 写入前的值。

func swap(Int16, MemoryOrder)

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

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

参数：

val: Int16 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int16 - 写入前的值。

class AtomicInt32

public class AtomicInt32

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

init(Int32)

public init(val: Int32)

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

参数：

val: Int32 - 原子类型的初始值。

func compareAndSwap(Int32, Int32)

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

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

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

参数：

old: Int32 - 与当前原子类型进行比较的值。
new: Int32 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: Int32 - 与当前原子类型进行比较的值。
new: Int32 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(Int32)

public func fetchAdd(val: Int32): Int32

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

参数：

val: Int32 - 与原子类型进行加操作的值。

返回值：

Int32 - 执行加操作前的值。

func fetchAdd(Int32, MemoryOrder)

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

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

参数：

val: Int32 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 执行加操作前的值。

func fetchAnd(Int32)

public func fetchAnd(val: Int32): Int32

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

参数：

val: Int32 - 与原子类型进行与操作的值。

返回值：

Int32 - 执行与操作前的值。

func fetchAnd(Int32, MemoryOrder)

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

参数：

val: Int32 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 执行与操作前的值。

func fetchOr(Int32)

public func fetchOr(val: Int32): Int32

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

参数：

val: Int32 - 与原子类型进行或操作的值。

返回值：

Int32 - 执行或操作前的值。

func fetchOr(Int32, MemoryOrder)

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

参数：

val: Int32 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 执行或操作前的值。

func fetchSub(Int32)

public func fetchSub(val: Int32): Int32

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

参数：

val: Int32 - 与原子类型进行减操作的值。

返回值：

Int32 - 执行减操作前的值。

func fetchSub(Int32, MemoryOrder)

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

参数：

val: Int32 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 执行减操作前的值。

func fetchXor(Int32)

public func fetchXor(val: Int32): Int32

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

参数：

val: Int32 - 与原子类型进行异或操作的值。

返回值：

Int32 - 执行异或操作前的值。

func fetchXor(Int32, MemoryOrder)

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

参数：

val: Int32 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 执行异或操作前的值。

func load()

public func load(): Int32

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

返回值：

Int32 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int32

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 当前原子类型的值。

func store(Int32)

public func store(val: Int32): Unit

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

参数：

val: Int32 - 写入原子类型的值。

func store(Int32, MemoryOrder)

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

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

参数：

val: Int32 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Int32)

public func swap(val: Int32): Int32

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

参数：

val: Int32 - 写入原子类型的值。

返回值：

Int32 - 写入前的值。

func swap(Int32, MemoryOrder)

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

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

参数：

val: Int32 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int32 - 写入前的值。

class AtomicInt64

public class AtomicInt64

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

init(Int64)

public init(val: Int64)

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

参数：

val: Int64 - 原子类型的初始值。

func compareAndSwap(Int64, Int64)

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

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

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

参数：

old: Int64 - 与当前原子类型进行比较的值。
new: Int64 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: Int64 - 与当前原子类型进行比较的值。
new: Int64 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(Int64)

public func fetchAdd(val: Int64): Int64

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

参数：

val: Int64 - 与原子类型进行加操作的值。

返回值：

Int64 - 执行加操作前的值。

func fetchAdd(Int64, MemoryOrder)

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

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

参数：

val: Int64 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 执行加操作前的值。

func fetchAnd(Int64)

public func fetchAnd(val: Int64): Int64

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

参数：

val: Int64 - 与原子类型进行与操作的值。

返回值：

Int64 - 执行与操作前的值。

func fetchAnd(Int64, MemoryOrder)

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

参数：

val: Int64 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 执行与操作前的值。

func fetchOr(Int64)

public func fetchOr(val: Int64): Int64

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

参数：

val: Int64 - 与原子类型进行或操作的值。

返回值：

Int64 - 执行或操作前的值。

func fetchOr(Int64, MemoryOrder)

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

参数：

val: Int64 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 执行或操作前的值。

func fetchSub(Int64)

public func fetchSub(val: Int64): Int64

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

参数：

val: Int64 - 与原子类型进行减操作的值。

返回值：

Int64 - 执行减操作前的值。

func fetchSub(Int64, MemoryOrder)

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

参数：

val: Int64 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 执行减操作前的值。

func fetchXor(Int64)

public func fetchXor(val: Int64): Int64

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

参数：

val: Int64 - 与原子类型进行异或操作的值。

返回值：

Int64 - 执行异或操作前的值。

func fetchXor(Int64, MemoryOrder)

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

参数：

val: Int64 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 执行异或操作前的值。

func load()

public func load(): Int64

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

返回值：

Int64 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int64

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 当前原子类型的值。

func store(Int64)

public func store(val: Int64): Unit

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

参数：

val: Int64 - 写入原子类型的值。

func store(Int64, MemoryOrder)

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

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

参数：

val: Int64 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Int64)

public func swap(val: Int64): Int64

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

参数：

val: Int64 - 写入原子类型的值。

返回值：

Int64 - 写入前的值。

func swap(Int64, MemoryOrder)

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

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

参数：

val: Int64 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int64 - 写入前的值。

class AtomicInt8

public class AtomicInt8

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

init(Int8)

public init(val: Int8)

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

参数：

val: Int8 - 原子类型的初始值。

func compareAndSwap(Int8, Int8)

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

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

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

参数：

old: Int8 - 与当前原子类型进行比较的值。
new: Int8 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: Int8 - 与当前原子类型进行比较的值。
new: Int8 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(Int8)

public func fetchAdd(val: Int8): Int8

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

参数：

val: Int8 - 与原子类型进行加操作的值。

返回值：

Int8 - 执行加操作前的值。

func fetchAdd(Int8, MemoryOrder)

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

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

参数：

val: Int8 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 执行加操作前的值。

func fetchAnd(Int8)

public func fetchAnd(val: Int8): Int8

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

参数：

val: Int8 - 与原子类型进行与操作的值。

返回值：

Int8 - 执行与操作前的值。

func fetchAnd(Int8, MemoryOrder)

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

参数：

val: Int8 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 执行与操作前的值。

func fetchOr(Int8)

public func fetchOr(val: Int8): Int8

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

参数：

val: Int8 - 与原子类型进行或操作的值。

返回值：

Int8 - 执行或操作前的值。

func fetchOr(Int8, MemoryOrder)

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

参数：

val: Int8 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 执行或操作前的值。

func fetchSub(Int8)

public func fetchSub(val: Int8): Int8

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

参数：

val: Int8 - 与原子类型进行减操作的值。

返回值：

Int8 - 执行减操作前的值。

func fetchSub(Int8, MemoryOrder)

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

参数：

val: Int8 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 执行减操作前的值。

func fetchXor(Int8)

public func fetchXor(val: Int8): Int8

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

参数：

val: Int8 - 与原子类型进行异或操作的值。

返回值：

Int8 - 执行异或操作前的值。

func fetchXor(Int8, MemoryOrder)

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

参数：

val: Int8 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 执行异或操作前的值。

func load()

public func load(): Int8

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

返回值：

Int8 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): Int8

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 当前原子类型的值。

func store(Int8)

public func store(val: Int8): Unit

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

参数：

val: Int8 - 写入原子类型的值。

func store(Int8, MemoryOrder)

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

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

参数：

val: Int8 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Int8)

public func swap(val: Int8): Int8

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

参数：

val: Int8 - 写入原子类型的值。

返回值：

Int8 - 写入前的值。

func swap(Int8, MemoryOrder)

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

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

参数：

val: Int8 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Int8 - 写入前的值。

class AtomicOptionReference

public class AtomicOptionReference<T> where T <: Object

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

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

init(Option<T>)

public init(val: Option<T>)

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

参数：

val: Option<T> - 原子类型的初始值。

func compareAndSwap(Option<T>, Option<T>)

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

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

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

参数：

old: Option<T> - 与当前原子类型进行比较的值。
new: Option<T> - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: Option<T> - 与当前原子类型进行比较的值。
new: Option<T> - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func load()

public func load(): Option<T>

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

返回值：

Option<T> - 当前原子类型的值。

func load(MemoryOrder)

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

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Option<T> - 当前原子类型的值。

func store(Option<T>)

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

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

参数：

val: Option<T> - 写入原子类型的值。

func store(Option<T>, MemoryOrder)

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

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

参数：

val: Option<T> - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(Option<T>)

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

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

参数：

val: Option<T> - 写入原子类型的值。

返回值：

Option<T> - 写入前的值。

func swap(Option<T>, MemoryOrder)

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

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

参数：

val: Option<T> - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

Option<T> - 写入前的值。

class AtomicReference

public class AtomicReference<T> where T <: Object

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

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

init(T)

public init(val: T)

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

参数：

val: T - 原子类型的初始值。

func compareAndSwap(T, T)

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

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

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

参数：

old: T - 与当前原子类型进行比较的值。
new: T - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: T - 与当前原子类型进行比较的值。
new: T - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func load()

public func load(): T

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

返回值：

T - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): T

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

T - 当前原子类型的值。

func store(T)

public func store(val: T): Unit

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

参数：

val: T - 写入原子类型的值。

func store(T, MemoryOrder)

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

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

参数：

val: T - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(T)

public func swap(val: T): T

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

参数：

val: T - 写入原子类型的值。

返回值：

T - 写入前的值。

func swap(T, MemoryOrder)

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

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

参数：

val: T - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

T - 写入前的值。

class AtomicUInt16

public class AtomicUInt16

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

init(UInt16)

public init(val: UInt16)

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

参数：

val: UInt16 - 原子类型的初始值。

func compareAndSwap(UInt16, UInt16)

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

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

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

参数：

old: UInt16 - 与当前原子类型进行比较的值。
new: UInt16 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: UInt16 - 与当前原子类型进行比较的值。
new: UInt16 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(UInt16)

public func fetchAdd(val: UInt16): UInt16

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

参数：

val: UInt16 - 与原子类型进行加操作的值。

返回值：

UInt16 - 执行加操作前的值。

func fetchAdd(UInt16, MemoryOrder)

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

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

参数：

val: UInt16 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 执行加操作前的值。

func fetchAnd(UInt16)

public func fetchAnd(val: UInt16): UInt16

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

参数：

val: UInt16 - 与原子类型进行与操作的值。

返回值：

UInt16 - 执行与操作前的值。

func fetchAnd(UInt16, MemoryOrder)

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

参数：

val: UInt16 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 执行与操作前的值。

func fetchOr(UInt16)

public func fetchOr(val: UInt16): UInt16

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

参数：

val: UInt16 - 与原子类型进行或操作的值。

返回值：

UInt16 - 执行或操作前的值。

func fetchOr(UInt16, MemoryOrder)

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

参数：

val: UInt16 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 执行或操作前的值。

func fetchSub(UInt16)

public func fetchSub(val: UInt16): UInt16

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

参数：

val: UInt16 - 与原子类型进行减操作的值。

返回值：

UInt16 - 执行减操作前的值。

func fetchSub(UInt16, MemoryOrder)

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

参数：

val: UInt16 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 执行减操作前的值。

func fetchXor(UInt16)

public func fetchXor(val: UInt16): UInt16

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

参数：

val: UInt16 - 与原子类型进行异或操作的值。

返回值：

UInt16 - 执行异或操作前的值。

func fetchXor(UInt16, MemoryOrder)

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

参数：

val: UInt16 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 执行异或操作前的值。

func load()

public func load(): UInt16

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

返回值：

UInt16 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt16

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 当前原子类型的值。

func store(UInt16)

public func store(val: UInt16): Unit

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

参数：

val: UInt16 - 写入原子类型的值。

func store(UInt16, MemoryOrder)

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

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

参数：

val: UInt16 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(UInt16)

public func swap(val: UInt16): UInt16

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

参数：

val: UInt16 - 写入原子类型的值。

返回值：

UInt16 - 写入前的值。

func swap(UInt16, MemoryOrder)

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

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

参数：

val: UInt16 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt16 - 写入前的值。

class AtomicUInt32

public class AtomicUInt32

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

init(UInt32)

public init(val: UInt32)

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

参数：

val: UInt32 - 原子类型的初始值。

func compareAndSwap(UInt32, UInt32)

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

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

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

参数：

old: UInt32 - 与当前原子类型进行比较的值。
new: UInt32 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: UInt32 - 与当前原子类型进行比较的值。
new: UInt32 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(UInt32)

public func fetchAdd(val: UInt32): UInt32

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

参数：

val: UInt32 - 与原子类型进行加操作的值。

返回值：

UInt32 - 执行加操作前的值。

func fetchAdd(UInt32, MemoryOrder)

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

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

参数：

val: UInt32 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 执行加操作前的值。

func fetchAnd(UInt32)

public func fetchAnd(val: UInt32): UInt32

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

参数：

val: UInt32 - 与原子类型进行与操作的值。

返回值：

UInt32 - 执行与操作前的值。

func fetchAnd(UInt32, MemoryOrder)

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

参数：

val: UInt32 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 执行与操作前的值。

func fetchOr(UInt32)

public func fetchOr(val: UInt32): UInt32

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

参数：

val: UInt32 - 与原子类型进行或操作的值。

返回值：

UInt32 - 执行或操作前的值。

func fetchOr(UInt32, MemoryOrder)

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

参数：

val: UInt32 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 执行或操作前的值。

func fetchSub(UInt32)

public func fetchSub(val: UInt32): UInt32

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

参数：

val: UInt32 - 与原子类型进行减操作的值。

返回值：

UInt32 - 执行减操作前的值。

func fetchSub(UInt32, MemoryOrder)

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

参数：

val: UInt32 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 执行减操作前的值。

func fetchXor(UInt32)

public func fetchXor(val: UInt32): UInt32

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

参数：

val: UInt32 - 与原子类型进行异或操作的值。

返回值：

UInt32 - 执行异或操作前的值。

func fetchXor(UInt32, MemoryOrder)

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

参数：

val: UInt32 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 执行异或操作前的值。

func load()

public func load(): UInt32

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

返回值：

UInt32 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt32

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 当前原子类型的值。

func store(UInt32)

public func store(val: UInt32): Unit

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

参数：

val: UInt32 - 写入原子类型的值。

func store(UInt32, MemoryOrder)

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

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

参数：

val: UInt32 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(UInt32)

public func swap(val: UInt32): UInt32

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

参数：

val: UInt32 - 写入原子类型的值。

返回值：

UInt32 - 写入前的值。

func swap(UInt32, MemoryOrder)

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

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

参数：

val: UInt32 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt32 - 写入前的值。

class AtomicUInt64

public class AtomicUInt64

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

init(UInt64)

public init(val: UInt64)

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

参数：

val: UInt64 - 原子类型的初始值。

func compareAndSwap(UInt64, UInt64)

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

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

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

参数：

old: UInt64 - 与当前原子类型进行比较的值。
new: UInt64 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: UInt64 - 与当前原子类型进行比较的值。
new: UInt64 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(UInt64)

public func fetchAdd(val: UInt64): UInt64

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

参数：

val: UInt64 - 与原子类型进行加操作的值。

返回值：

UInt64 - 执行加操作前的值。

func fetchAdd(UInt64, MemoryOrder)

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

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

参数：

val: UInt64 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 执行加操作前的值。

func fetchAnd(UInt64)

public func fetchAnd(val: UInt64): UInt64

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

参数：

val: UInt64 - 与原子类型进行与操作的值。

返回值：

UInt64 - 执行与操作前的值。

func fetchAnd(UInt64, MemoryOrder)

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

参数：

val: UInt64 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 执行与操作前的值。

func fetchOr(UInt64)

public func fetchOr(val: UInt64): UInt64

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

参数：

val: UInt64 - 与原子类型进行或操作的值。

返回值：

UInt64 - 执行或操作前的值。

func fetchOr(UInt64, MemoryOrder)

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

参数：

val: UInt64 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 执行或操作前的值。

func fetchSub(UInt64)

public func fetchSub(val: UInt64): UInt64

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

参数：

val: UInt64 - 与原子类型进行减操作的值。

返回值：

UInt64 - 执行减操作前的值。

func fetchSub(UInt64, MemoryOrder)

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

参数：

val: UInt64 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 执行减操作前的值。

func fetchXor(UInt64)

public func fetchXor(val: UInt64): UInt64

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

参数：

val: UInt64 - 与原子类型进行异或操作的值。

返回值：

UInt64 - 执行异或操作前的值。

func fetchXor(UInt64, MemoryOrder)

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

参数：

val: UInt64 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 执行异或操作前的值。

func load()

public func load(): UInt64

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

返回值：

UInt64 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt64

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 当前原子类型的值。

func store(UInt64)

public func store(val: UInt64): Unit

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

参数：

val: UInt64 - 写入原子类型的值。

func store(UInt64, MemoryOrder)

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

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

参数：

val: UInt64 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(UInt64)

public func swap(val: UInt64): UInt64

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

参数：

val: UInt64 - 写入原子类型的值。

返回值：

UInt64 - 写入前的值。

func swap(UInt64, MemoryOrder)

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

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

参数：

val: UInt64 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt64 - 写入前的值。

class AtomicUInt8

public class AtomicUInt8

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

init(UInt8)

public init(val: UInt8)

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

参数：

val: UInt8 - 原子类型的初始值。

func compareAndSwap(UInt8, UInt8)

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

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

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

参数：

old: UInt8 - 与当前原子类型进行比较的值。
new: UInt8 - 比较结果相等时，写入原子类型的值。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

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。

参数：

old: UInt8 - 与当前原子类型进行比较的值。
new: UInt8 - 比较结果相等时，写入原子类型的值。
successOrder!: MemoryOrder - CAS 操作成功时，执行“读 > 修改 > 写”操作需要的内存排序方式。
failureOrder!: MemoryOrder - CAS 操作失败时，执行“读”操作需要的内存排序方式。

返回值：

Bool - 比较后交换成功返回 true，否则返回 false。

func fetchAdd(UInt8)

public func fetchAdd(val: UInt8): UInt8

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

参数：

val: UInt8 - 与原子类型进行加操作的值。

返回值：

UInt8 - 执行加操作前的值。

func fetchAdd(UInt8, MemoryOrder)

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

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

参数：

val: UInt8 - 与原子类型进行加操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 执行加操作前的值。

func fetchAnd(UInt8)

public func fetchAnd(val: UInt8): UInt8

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

参数：

val: UInt8 - 与原子类型进行与操作的值。

返回值：

UInt8 - 执行与操作前的值。

func fetchAnd(UInt8, MemoryOrder)

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

参数：

val: UInt8 - 与原子类型进行与操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 执行与操作前的值。

func fetchOr(UInt8)

public func fetchOr(val: UInt8): UInt8

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

参数：

val: UInt8 - 与原子类型进行或操作的值。

返回值：

UInt8 - 执行或操作前的值。

func fetchOr(UInt8, MemoryOrder)

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

参数：

val: UInt8 - 与原子类型进行或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 执行或操作前的值。

func fetchSub(UInt8)

public func fetchSub(val: UInt8): UInt8

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

参数：

val: UInt8 - 与原子类型进行减操作的值。

返回值：

UInt8 - 执行减操作前的值。

func fetchSub(UInt8, MemoryOrder)

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

参数：

val: UInt8 - 与原子类型进行减操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 执行减操作前的值。

func fetchXor(UInt8)

public func fetchXor(val: UInt8): UInt8

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

参数：

val: UInt8 - 与原子类型进行异或操作的值。

返回值：

UInt8 - 执行异或操作前的值。

func fetchXor(UInt8, MemoryOrder)

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

参数：

val: UInt8 - 与原子类型进行异或操作的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 执行异或操作前的值。

func load()

public func load(): UInt8

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

返回值：

UInt8 - 当前原子类型的值。

func load(MemoryOrder)

public func load(memoryOrder!: MemoryOrder): UInt8

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

参数：

memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 当前原子类型的值。

func store(UInt8)

public func store(val: UInt8): Unit

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

参数：

val: UInt8 - 写入原子类型的值。

func store(UInt8, MemoryOrder)

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

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

参数：

val: UInt8 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

func swap(UInt8)

public func swap(val: UInt8): UInt8

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

参数：

val: UInt8 - 写入原子类型的值。

返回值：

UInt8 - 写入前的值。

func swap(UInt8, MemoryOrder)

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

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

参数：

val: UInt8 - 写入原子类型的值。
memoryOrder!: MemoryOrder - 当前操作的内存排序方式。

返回值：

UInt8 - 写入前的值。

class Barrier

public class Barrier

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

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

init(Int64)

public init(count: Int64)

功能：创建 Barrier 对象。

参数：

count: Int64 - 表示需要协调的线程数。

异常：

IllegalArgumentException - 参数 count 为负数。

func wait(Duration)

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

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

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

参数：

timeout!: Duration - 阻塞时等待的最大时长，其默认值为 Duration.Max。

class Monitor

public class Monitor <: ReentrantMutex

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

这是一种利用共享变量进行线程同步的机制，当一些线程因等待共享变量的某个条件成立而挂起时，另一些线程改变共享的变量，使条件成立，然后执行唤醒操作。这使得挂起的线程被唤醒后可以继续执行。

父类型：

ReentrantMutex

func notify()

public func notify(): Unit

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

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，抛出异常。

func notifyAll()

public func notifyAll(): Unit

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

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，抛出异常。

func wait(Duration)

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

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

参数：

timeout!: Duration - 挂起时间，其默认值为 Duration.Max。

返回值：

Bool - 如果 Monitor 被其它线程唤醒，返回 true；如果超时，则返回 false。

异常：

IllegalArgumentException - 如果 timeout 小于等于 Duration.Zero，抛出异常。
IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，抛出异常。

class MultiConditionMonitor

public class MultiConditionMonitor <: ReentrantMutex

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

注意：

该类应仅当在 Monitor 类不足以实现高级并发算法时被使用。

初始化时，MultiConditionMonitor 没有与之相关的条件变量。

每次调用 newCondition 将创建一个新的等待队列并与当前对象关联，并返回ConditionID类型实例作为唯一标识符。

父类型：

ReentrantMutex

func newCondition()

public func newCondition(): ConditionID

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

返回值：

ConditionID - 新的 ConditionID。

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，抛出异常。

func notify(ConditionID)

public func notify(condID: ConditionID): Unit

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

参数：

condID: ConditionID - 条件变量。

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，或 condID 不是由该 MultiConditionMonitor 实例通过 newCondition 函数创建时，抛出异常。

func notifyAll(ConditionID)

public func notifyAll(condID: ConditionID): Unit

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

参数：

condID: ConditionID - 条件变量。

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，或 condID 不是由该 MultiConditionMonitor 实例通过 newCondition 函数创建时，抛出异常。

func wait(ConditionID, Duration)

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

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

参数：

condID: ConditionID - 条件变量。
timeout!: Duration - 挂起时间，其默认值为 Duration.Max。

返回值：

Bool - 如果该 Monitor 指定的条件变量被其它线程唤醒，返回 true；如果超时，则返回 false。

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，或者挂起时间超过 timeout 或 condID 不是由该 MultiConditionMonitor 实例通过 newCondition 函数创建时，抛出异常。
IllegalArgumentException - 如果 timeout 小于等于 Duration.Zero，抛出异常。

class ReentrantMutex

public open class ReentrantMutex <: IReentrantMutex

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

可重入互斥锁的作用是对临界区加以保护，使得任意时刻最多只有一个线程能够执行临界区的代码。当一个线程试图获取一个已被其他线程持有的锁时，该线程会被阻塞，直到锁被释放，该线程才会被唤醒，可重入是指线程获取该锁后可再次获得该锁。

注意：

ReentrantMutex 是内置的互斥锁，开发者需要保证不继承它。

在访问共享数据之前，必须尝试获取锁。

处理完共享数据后，必须进行解锁，以便其他线程可以获得锁。

父类型：

IReentrantMutex

init()

public init()

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

异常：

IllegalSynchronizationStateException - 当出现系统错误时，抛出异常。

func tryLock()

public open func tryLock(): Bool

功能：尝试锁定互斥体。

返回值：

Bool - 如果互斥体已被锁定，则返回 false；反之，则锁定互斥体并返回 true。

func unlock

public open func unlock(): Unit

功能：解锁互斥体。

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

异常：

IllegalSynchronizationStateException - 如果当前线程没有持有该互斥体，抛出异常。

class ReentrantReadMutex

public class ReentrantReadMutex <: ReentrantMutex

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

父类型：

ReentrantMutex

func lock()

public func lock(): Unit

功能：获取读锁。

注意：

在公平模式下，如果没有其他线程持有或等待写锁，或是当前线程已持有读锁，则立即持有读锁；否则，当前线程进入等待状态。

在非公平模式下，如果没有其他线程持有或等待写锁，则立即持有读锁；如果有其他线程持有写锁，当前线程进入等待状态；否则，线程是否能立即持有读锁不做保证。

多个线程可以同时持有读锁并且一个线程可以重复多次持有读锁；如果一个线程持有写锁，那么它仍可以持有读锁。

func tryLock()

public func tryLock(): Bool

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

返回值：

Bool - 若成功获取读锁，返回 true；若未能获取读锁，返回 false。

func unlock()

public func unlock(): Unit

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

异常：

IllegalSynchronizationStateException - 当前线程未持有读锁，那么将抛出异常。

class ReentrantReadWriteMutex

public class ReentrantReadWriteMutex

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

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

读写锁的特殊性质说明：

写互斥性：只有唯一的线程能够持有写锁。当一个线程持有写锁，而其他线程再次获取锁（读锁或是写锁）时将被阻塞。
读并发性：允许多个线程同时持有读锁。当一个线程持有读锁，其他线程仍然可以获取读锁。但其他线程获取写锁时将被阻塞。
可重入性：一个线程可以重复获取锁。
- 当线程已持有写锁时，它可以继续获取写锁或者读锁。只有当锁释放操作和获取操作一一对应时，锁才被完全释放。
- 当线程已持有读锁时，它可以继续获取读锁。当锁释放操作和获取操作一一对应时，锁才被完全释放。注意，不允许在持有读锁的情况下获取写锁，这将抛出异常。
锁降级：一个线程在经历“持有写锁--持有读锁--释放写锁”后，它持有的是读锁而不再是写锁。
读写公平性：读写锁支持两种不同的模式，分别为“公平”及“非公平”模式。
- 在非公平模式下，读写锁对线程获取锁的顺序不做任何保证。
- 在公平模式下，当线程获取读锁时（当前线程未持有读锁），如果写锁已被获取或是存在线程等待写锁，那么当前线程无法获取读锁并进入等待。
- 在公平模式下，写锁释放会优先唤醒所有读线程、读锁释放会优先唤醒一个等待写锁的线程。当存在多个线程等待写锁，他们之间被唤醒的先后顺序并不做保证。

init(ReadWriteMutexMode)

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

功能：构造读写锁。

参数：

mode!: ReadWriteMutexMode - 读写锁模式，默认值为 Unfair，即构造“非公平”的读写锁。

class ReentrantWriteMutex

public class ReentrantWriteMutex <: ReentrantMutex

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

父类型：

ReentrantMutex

func lock()

public func lock(): Unit

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

异常：

IllegalSynchronizationStateException - 当前线程已持有读锁。

func tryLock()

public func tryLock(): Bool

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

返回值：

Bool - 若成功获取写锁，返回 true；若未能获取写锁，返回 false。

func unlock()

public func unlock(): Unit

功能：释放写锁。

注意：

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

在公平模式下，如果写锁被释放并且存在线程等待读锁，那么优先唤醒这些等待线程；如果没有线程等待读锁，但存在线程等待写锁，那么唤醒其中一个线程。

在非公平模式下，如果写锁被释放，优先唤醒等待写锁的线程还是等待读锁的线程不做保证，交由具体实现决定。

异常：

IllegalSynchronizationStateException - 当前线程未持有写锁。

class Semaphore

public class Semaphore

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

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

init(Int64)

public init(count: Int64)

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

参数：

count: Int64 - 计数器初始值, 取值范围 [0, Int64.Max]。

异常：

IllegalArgumentException - 参数 count 为负数时抛出异常。

func acquire(Int64)

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

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

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

参数：

amount!: Int64 - 向对象内部计数器中获取的数值，默认值为 1。

异常：

IllegalArgumentException - 参数 amount 为负数，或大于初始值。

func release(Int64)

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

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

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

参数：

amount!: Int64 - 向对象内部计数器中释放的数值，默认值为 1。

返回值：

Unit - 如果当前计数器小于要求的数值，则获取失败并返回 false；成功获取值时返回 true。

异常：

IllegalArgumentException - 参数 amount 为负数，或大于初始值。

func tryAcquire(Int64)

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

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

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

参数：

amount!: Int64 - 向对象内部计数器中获取的数值，默认值为 1。

返回值：

Bool - 如果当前计数器小于要求的数值，则获取失败并返回 false；成功获取值时返回 true。

异常：

IllegalArgumentException - 参数 amount 为负数，或大于初始值。

class SyncCounter

public class SyncCounter

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

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

init(Int64)

public init(count: Int64)

功能：创建倒数计数器。

参数：

count: Int64 - 倒数计数器的初始值。

异常：

IllegalArgumentException - 如果参数 count 为负数。

func dec()

public func dec(): Unit

功能：计数器减一。

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

func waitUntilZero(Duration)

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

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

参数：

timeout!: Duration - 阻塞时等待的最大时长，其默认值为 Duration.Max。

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 创建时指定的结束条件。

父类型：

Equatable<Timer>
Hashable

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 会立刻再次被调度执行。

参数：

delay: Duration - 从现在开始到关联 Task 首次被调度执行的时间间隔
task: () ->Option<Duration> - 该 Timer 调度执行的 Task

返回值：

Timer - 一个 Timer 实例

static func once(Duration, ()->Unit)

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

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

参数:

delay: 从现在开始到 Task 被执行的时间间隔。取值范围 [Duration.Min, Duration.Max]，小于或等于 Duration.Zero 时 Task 将立即被执行。
task: 待定时执行的任务。

返回值: Timer 对象实例。

示例:

import std.time.MonoTime

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

    sleep(Duration.second * 2)
    0
}

运行结果:

Tick at: 1s2ms74us551ns

static func repeat(Duration, Duration, ()->Unit, CatchupStyle)

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

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

参数:

delay: 从现在开始到 Task 被执行的时间间隔。取值范围 [Duration.Min, Duration.Max]，小于或等于 Duration.Zero 时 Task 将立即被执行。
interval: 两次 Task 之间的时间间隔。取值范围 (Duration.Zero, Duration.Max]。
task: 待定时执行的任务。
style: 追平策略，默认 Burst。当 Task 执行时间过长时，后续任务执行时间点可能发生延迟，不同的追平策略适用于不同的场景，详见 CatchupStyle 说明。

返回值: Timer 对象实例。

异常:

IllegalArgumentException: 当 interval 小于等于 Duration.Zero 时，抛出异常。

示例:

import std.sync.{Timer}
import std.time.{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

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 对象实例。

参数:

period: 重复周期的最大持续时间，从 delay 之后开始计时。取值范围 (Duration.Zero, Duration.Max]。
delay: 从现在开始到 Task 被执行的时间间隔。取值范围 [Duration.Min, Duration.Max]，小于或等于 Duration.Zero时 Task 将立即被执行。
interval: 两次 Task 之间的时间间隔。取值范围 (Duration.Zero, Duration.Max]。
task: 待定时执行的任务。
style: 追平策略，默认 Burst。当 Task 执行时间过长时，后续任务执行时间点可能发生延迟，不同的追平策略适用于不同的场景，详见 CatchupStyle 说明。

返回值: Timer 对象实例。

异常:

IllegalArgumentException: 当 period 小于等于 Duration.Zero 或 interval 小于等于 Duration.Zero 时，抛出异常。

示例:

import std.sync.{Timer}
import std.time.{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

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 对象实例。

参数:

count: Task 最大执行次数。取值范围 (0, Int64.Max]。
delay: 从现在开始到 Task 被执行的时间间隔。取值范围 [Duration.Min, Duration.Max]，小于或等于 Duration.Zero 时 Task 将立即被执行。
interval: 两次 Task 之间的时间间隔。取值范围 (Duration.Zero, Duration.Max]。
task: 待定时执行的任务。
style: 追平策略，默认 Burst。当 Task 执行时间过长时，后续任务执行时间点可能发生延迟，不同的追平策略适用于不同的场景，详见 CatchupStyle 说明。

返回值: Timer 对象实例。

异常:

IllegalArgumentException: 当 count <= 0 或 interval 小于等于 Duration.Zero 时，抛出异常。

示例:

import std.sync.{Timer}
import std.time.{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

func cancel()

public func cancel(): Unit

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

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

func hashCode()

public func hashCode(): Int64

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

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

operator func !=(Timer)

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

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

返回值：

Bool - 若两个 Timer 不是同一个实例，则返回 true，否则返回 false。

operator func ==(Timer)

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

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

返回值：

Bool - 若两个 Timer 是同一个实例，则返回 true，否则返回 false。

仓颉编程语言库 API