sync 包
介绍
随着越来越多的计算机开始使用多核处理器，要充分发挥多核的优势，并发编程也变得越来越重要。
不同编程语言会以不同的方式实现线程。一些编程语言通过调用操作系统 API 来创建线程，意味着每个语言线程对应一个操作系统线程，一般称之为 1:1 的线程模型；也有一些编程语言提供特殊的线程实现，允许多个语言线程在不同数量的操作系统线程的上下文中切换执行，这种也被称为 M:N 的线程模型，即 M 个语言线程在 N 个操作系统线程上调度执行，其中 M 和 N 不一定相等。
仓颉编程语言希望给开发者提供一个友好、高效、统一的并发编程界面，让开发者无需关心操作系统线程、用户态线程等概念上的差异，同时屏蔽底层实现细节，因此我们只提供一个仓颉线程的概念。仓颉线程采用的是 M:N 线程模型的实现，因此本质上它是一种用户态的轻量级线程，支持抢占，且相比操作系统线程内存资源占用更小。
当开发者希望并发执行某一段代码时，只需创建一个仓颉线程即可。
要创建一个新的仓颉线程，可以使用关键字 spawn 并传递一个无形参的 lambda 表达式，该 lambda 表达式即为我们想在新线程中执行的代码。
sync 包主要提供了不同类型的原子操作，可重入互斥锁及其接口，利用共享变量的线程同步机制以及定时器的功能。
原子操作提供了包括整数类型、Bool 类型和引用类型的原子操作。
其中整数类型包括：Int8、Int16、Int32、Int64、UInt8、UInt16、UInt32、UInt64。
整数类型的原子操作支持基本的读写、交换以及算术运算操作，需要注意的是：
-
交换操作和算数操作的返回值是修改前的值。
-
compareAndSwap 是判断当前原子变量的值是否等于 old 值，如果等于，则使用 new 值替换；否则不替换。
Bool 类型和引用类型的原子操作只提供读写和交换操作，需要注意的是：
引用类型原子操作只对引用类型有效。
主要接口
enum MemoryOrder
public enum MemoryOrder {
| SeqCst
}
内存顺序枚举类型。
SeqCst
SeqCst
功能：构造顺序一致性内存顺序枚举类型实例。
DefaultMemoryOrder
public let DefaultmemoryOrder!: MemoryOrder = MemoryOrder.SeqCst
默认内存排序
class AtomicInt8
public class AtomicInt8 {
public init(val: Int8)
}
此类是封装了 Int8 类型数据的原子类型，可以通过该类型实例执行与 Int8 类型数据相关的原子操作。
init
public init(val: Int8)
功能：构造一个封装 Int8 数据类型的原子类型 AtomicInt8 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Int8
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Int8
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Int8): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Int8, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Int8): Int8
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Int8, new: Int8): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Int8, new: Int8, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: Int8): Int8
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: Int8): Int8
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: Int8): Int8
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: Int8): Int8
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: Int8): Int8
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: Int8, memoryOrder!: MemoryOrder): Int8
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicInt16
public class AtomicInt16 {
public init(val: Int16)
}
此类提供 Int16 类型的原子操作相关函数。
init
public init(val: Int16)
功能：构造一个封装 Int16 数据类型的原子类型 AtomicInt16 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Int16
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Int16
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Int16): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Int16, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Int16): Int16
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Int16, new: Int16): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Int16, new: Int16, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: Int16): Int16
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: Int16): Int16
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: Int16): Int16
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: Int16): Int16
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: Int16): Int16
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: Int16, memoryOrder!: MemoryOrder): Int16
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicInt32
public class AtomicInt32 {
public init(val: Int32)
}
此类提供 Int32 类型的原子操作相关函数。
init
public init(val: Int32)
功能：构造一个封装 Int32 数据类型的原子类型 AtomicInt32 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Int32
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Int32
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Int32): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Int32, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Int32): Int32
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Int32, new: Int32): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Int32, new: Int32, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: Int32): Int32
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: Int32): Int32
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: Int32): Int32
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: Int32): Int32
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: Int32): Int32
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: Int32, memoryOrder!: MemoryOrder): Int32
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicInt64
public class AtomicInt64 {
public init(val: Int64)
}
此类提供 Int64 类型的原子操作相关函数。
init
public init(val: Int64)
功能：构造一个封装 Int64 数据类型的原子类型 AtomicInt64 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Int64
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Int64
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Int64): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Int64, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Int64): Int64
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Int64, new: Int64): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Int64, new: Int64, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: Int64): Int64
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: Int64): Int64
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: Int64): Int64
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: Int64): Int64
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: Int64): Int64
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: Int64, memoryOrder!: MemoryOrder): Int64
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicUInt8
public class AtomicUInt8 {
public init(val: UInt8)
}
此类是封装了 UInt8 类型数据的原子类型，可以通过该类型实例执行与 UInt8 类型数据相关的原子操作。
init
public init(val: UInt8)
功能：构造一个封装 UInt8 数据类型的原子类型 AtomicUInt8 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): UInt8
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): UInt8
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: UInt8): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: UInt8, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: UInt8): UInt8
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: UInt8, new: UInt8): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: UInt8, new: UInt8, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: UInt8): UInt8
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: UInt8): UInt8
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: UInt8): UInt8
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: UInt8): UInt8
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: UInt8): UInt8
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: UInt8, memoryOrder!: MemoryOrder): UInt8
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicUInt16
public class AtomicUInt16 {
public init(val: UInt16)
}
此类提供 UInt16 类型的原子操作相关函数。
init
public init(val: UInt16)
功能：构造一个封装 UInt16 数据类型的原子类型 AtomicUInt16 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): UInt16
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): UInt16
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: UInt16): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: UInt16, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: UInt16): UInt16
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: UInt16, new: UInt16): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: UInt16, new: UInt16, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: UInt16): UInt16
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: UInt16): UInt16
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: UInt16): UInt16
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: UInt16): UInt16
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: UInt16): UInt16
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: UInt16, memoryOrder!: MemoryOrder): UInt16
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicUInt32
public class AtomicUInt32 {
public init(val: UInt32)
}
此类提供 UInt32 类型的原子操作相关函数。
init
public init(val: UInt32)
功能：构造一个封装 UInt32 数据类型的原子类型 AtomicUInt32 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): UInt32
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): UInt32
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: UInt32): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: UInt32, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: UInt32): UInt32
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: UInt32, new: UInt32): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: UInt32, new: UInt32, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: UInt32): UInt32
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: UInt32): UInt32
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: UInt32): UInt32
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: UInt32): UInt32
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: UInt32): UInt32
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: UInt32, memoryOrder!: MemoryOrder): UInt32
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicUInt64
public class AtomicUInt64 {
public init(val: UInt64)
}
此类提供 UInt64 类型的原子操作相关函数。
init
public init(val: UInt64)
功能：构造一个封装 UInt64 数据类型的原子类型 AtomicUInt64 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): UInt64
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): UInt64
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: UInt64): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: UInt64, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: UInt64): UInt64
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: UInt64, new: UInt64): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: UInt64, new: UInt64, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
func fetchAdd
public func fetchAdd(val: UInt64): UInt64
功能：加操作，采用默认内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加操作前的值。
参数：
- val：与原子类型进行加操作的值
返回值：执行加操作前的值
func fetchAdd
public func fetchAdd(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：加操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行加操作，将结果写入当前原子类型实例，并返回加法运算前的值。
参数：
- val：与原子类型进行加操作的值
- memoryOrder：内存排序方式
返回值：执行加操作前的值
func fetchSub
public func fetchSub(val: UInt64): UInt64
功能：减操作，采用默认内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
返回值：执行减操作前的值
func fetchSub
public func fetchSub(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：减操作，采用参数 memoryOrder 指定的内存排序方式，将原子类型的值与参数 val 进行减操作，将结果写入当前原子类型实例，并返回减操作前的值。
参数：
- val：与原子类型进行减操作的值
- memoryOrder：内存排序方式
返回值：执行减操作前的值
func fetchAnd
public func fetchAnd(val: UInt64): UInt64
功能：与操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
返回值：执行与操作前的值
func fetchAnd
public func fetchAnd(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：与操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行与操作，将结果写入当前原子类型实例，并返回与操作前的值。
参数：
- val：与原子类型进行与操作的值
- memoryOrder：内存排序方式
返回值：执行与操作前的值
func fetchOr
public func fetchOr(val: UInt64): UInt64
功能：或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
返回值：执行或操作前的值
func fetchOr
public func fetchOr(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行或操作，将结果写入当前原子类型实例，并返回或操作前的值。
参数：
- val：与原子类型进行或操作的值
- memoryOrder：内存排序方式
返回值：执行或操作前的值
func fetchXor
public func fetchXor(val: UInt64): UInt64
功能：异或操作，采用默认内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
返回值：执行异或操作前的值
func fetchXor
public func fetchXor(val: UInt64, memoryOrder!: MemoryOrder): UInt64
功能：异或操作，采用参数 memoryOrder 指定的内存排序方式，将当前原子类型实例的值与参数 val 进行异或操作，将结果写入当前原子类型实例，并返回异或操作前的值。
参数：
- val：与原子类型进行异或操作的值
- memoryOrder：内存排序方式
返回值：执行异或操作前的值
class AtomicBool
public class AtomicBool {
public init(val: Bool)
}
此类提供 Bool 类型的原子操作相关函数。
init
public init(val: Bool)
功能：构造一个封装 Bool 数据类型的原子类型 AtomicBool 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Bool
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Bool
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Bool): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Bool, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Bool): Bool
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Bool, memoryOrder!: MemoryOrder): Bool
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Bool, new: Bool): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Bool, new: Bool, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
class AtomicReference
public class AtomicReference<T> where T <: Object {
public init(val: T)
}
引用类型原子操作，该引用类型必须是 Object 的子类。
init
public init(val: T)
功能：构造一个封装 T 数据类型的原子类型 AtomicReference 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): T
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): T
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: T): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: T, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: T): T
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: T, memoryOrder!: MemoryOrder): T
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: T, new: T): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: T, new: T, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
class AtomicOptionReference
public class AtomicOptionReference<T> where T <: Object {
public init()
public init(val: Option<T>)
}
引用类型原子操作，该引用类型必须是 Object 的子类。
init
public init()
功能：构造一个空的 AtomicOptionReference 实例。
init
public init(val: Option<T>)
功能：构造一个封装 Option<T> 数据类型的原子类型 AtomicOptionReference 的实例，其内部数据初始值为入参 val 的值。
参数：
- val：原子类型的初始值
func load
public func load(): Option<T>
功能：获取操作，采用默认内存排序方式，读取原子类型的值。
返回值：当前原子类型的值
func load
public func load(memoryOrder!: MemoryOrder): Option<T>
功能：获取操作，采用参数 memoryOrder 指定的内存排序方式，读取原子类型的值。
参数：
- memoryOrder：内存排序方式
返回值：当前原子类型的值
func store
public func store(val: Option<T>): Unit
功能：写入操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
func store
public func store(val: Option<T>, memoryOrder!: MemoryOrder): Unit
功能：写入操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
func swap
public func swap(val: Option<T>): Option<T>
功能：交换操作，采用默认内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
返回值：写入前的值
func swap
public func swap(val: Option<T>, memoryOrder!: MemoryOrder): Option<T>
功能：交换操作，采用参数 memoryOrder 指定的内存排序方式，将参数 val 指定的值写入原子类型，并返回写入前的值。
参数：
- val：写入原子类型的值
- memoryOrder：内存排序方式
返回值：写入前的值
func compareAndSwap
public func compareAndSwap(old: Option<T>, new: Option<T>): Bool
功能：比较后交换操作，采用默认内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
返回值：比较后交换成功返回 true，否则返回 false
func compareAndSwap
public func compareAndSwap(old: Option<T>, new: Option<T>, successOrder!: MemoryOrder, failureOrder!: MemoryOrder): Bool
功能：比较后交换操作，采用参数 successOrder 和 failureOrder 指定的内存排序方式，比较当前原子类型的值与参数 old 指定的值是否相等：若相等，则写入参数 new 指定的值，并返回 true；否则，不写入值，并返回 false。
参数：
- old：与当前原子类型进行比较的值
- new：比较结果相等时写入原子类型的值
- successOrder：内存排序方式
- failureOrder：内存排序方式
返回值：比较后交换成功返回 true，否则返回 false
interface IReentrantMutex
public interface IReentrantMutex {
func lock(): Unit
func tryLock(): Bool
func unlock(): Unit
}
IReentrantMutex 是一个可重入互斥锁的公共接口，提供如下三个函数，开发者可通过该接口实现自己的可重入互斥锁。
注意：
- 开发者在实现该接口时需要保证底层互斥锁确实支持嵌套锁。
- 开发者在实现该接口时需要保证在当前线程时抛出
IllegalSynchronizationStateException。
func lock
func lock(): Unit
功能：锁定互斥体，如果互斥体已被锁定，则阻塞。
func tryLock
func tryLock(): Bool
功能：尝试锁定互斥体。
返回值：如果互斥体已被锁定，则返回 false；反之，则锁定互斥体并返回 true
func unlock
func unlock(): Unit
功能：解锁互斥体，如果互斥体被重复加锁了 N 次，那么需要调用 N 次该函数来完全解锁，一旦互斥体被完全解锁，如果有其他线程阻塞在此锁上，那么唤醒他们中的一个。
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
class ReentrantMutex
public open class ReentrantMutex <: IReentrantMutex {
public init()
}
可重入互斥锁的作用是对临界区加以保护，使得任意时刻最多只有一个线程能够执行临界区的代码。当一个线程试图获取一个已被其他线程持有的锁时，该线程会被阻塞，直到锁被释放，该线程才会被唤醒，可重入是指线程获取该锁后可再次获得该锁。
注意：ReentrantMutex 是内置的互斥锁，开发者需要保证不继承它。
使用可重入互斥锁时，必须牢记两条规则：
- 在访问共享数据之前，必须尝试获取锁
- 处理完共享数据后，必须进行解锁，以便其他线程可以获得锁
init
public init()
功能：创建可重入互斥锁。
异常：
- IllegalSynchronizationStateException：当出现系统错误时，抛出异常
func lock
public open func lock(): Unit
功能：锁定互斥体，如果互斥体已被锁定，则阻塞。
func tryLock
public open func tryLock(): Bool
功能：尝试锁定互斥体。
返回值：如果互斥体已被锁定，则返回 false；反之，则锁定互斥体并返回 true
func unlock
public open func unlock(): Unit
功能：解锁互斥体，如果互斥体被重复加锁了 N 次，那么需要调用 N 次该函数来完全解锁，一旦互斥体被完全解锁，如果有其他线程阻塞在此锁上，那么唤醒他们中的一个。
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
class IllegalSynchronizationStateException
public class IllegalSynchronizationStateException <: Exception {
public init()
public init(message: String)
}
此类为非法同步状态异常。
init
public init()
功能：创建一个 IllegalSynchronizationStateException 实例。
init
public init(message: String)
功能：创建一个 IllegalSynchronizationStateException 实例，其信息由参数 message 指定。
参数：
- message：预定义消息
synchronized 关键字
ReentrantMutex 在使用的时候仍然有诸多不便，比如稍不注意会忘了解锁，或者在持有互斥锁的情况下抛出异常不能自动释放持有的锁，等等。因此，仓颉编程语言提供一个 synchronized 关键字，搭配 ReentrantMutex 一起使用，来解决类似的问题。
通过在 synchronized 后面加上一个 ReentrantMutex 实例，对其后面修饰的代码块进行保护，可以使得任意时刻最多只有一个线程可以执行被保护的代码：
- 一个线程在进入
synchronized修饰的代码块之前，会自动获取ReentrantMutex实例对应的锁，如果无法获取锁，则当前线程被阻塞； - 一个线程在退出
synchronized修饰的代码块之前，会自动释放该ReentrantMutex实例的锁；
对于控制转移表达式（如 break、continue、return、throw），在导致程序的执行跳出 synchronized 代码块时，也符合上面第 2 条的说明，也就说也会自动释放 synchronized 表达式对应的锁。
注意：synchronized 关键字与 IReentrantMutex 接口不兼容。
class Monitor
public class Monitor <: ReentrantMutex {
public init()
}
Monitor 可以使线程阻塞并等待来自另一个线程的信号以恢复执行，这是一种利用共享变量进行线程同步的机制。
当一些线程因等待共享变量的某个条件成立而挂起时，另一些线程改变共享的变量，使条件成立，然后执行唤醒操作。这使得挂起的线程被唤醒后可以继续执行。
init
public init()
功能：通过默认构造函数创建 Monitor。
func wait
public func wait(timeout!: Duration = Duration.Max): Bool
功能：当前线程挂起，直到对应的 notify 函数被调用，或者挂起时间超过 timeout。
参数：
- timeout：
Duration类型，挂起时间，其默认值为Duration.Max
返回值：如果 Monitor 被其它线程唤醒，返回 true；如果超时，则返回 false
异常：
- IllegalArgumentException：如果
timeout <= Duration.Zero，抛出异常。 - IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
func notify
public func notify(): Unit
功能：唤醒等待在该 Montior 上的线程。
返回值：Unit
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
func notifyAll
public func notifyAll(): Unit
功能：唤醒所有等待在该 Montior 上的线程。
返回值：Unit
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
struct ConditionID
public struct ConditionID
ConditionID 实例表示线程间的共享变量。
class MultiConditionMonitor
public class MultiConditionMonitor <: ReentrantMutex {
public init()
}
MultiConditionMonitor 用于绑定一个互斥锁和多个条件变量。
注意：该类应仅当在 Monitor 类不足以实现高级并发算法时被使用。
初始化时，MultiConditionMonitor 没有与之相关的条件变量。每次调用 newCondition 将创建一个新的等待队列并与当前对象关联，并返回如下类型作为唯一标识符：
init
public init()
功能：通过默认构造函数创建 MultiConditionMonitor。
func newCondition
public func newCondition(): ConditionID
功能：创建一个与该 Monitor 相关的 ConditionID，可能被用来实现 “单互斥体多等待队列” 的并发原语。
返回值：新的 ConditionID
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，抛出异常
func wait
public func wait(condID: ConditionID, timeout!: Duration = Duration.Max): Bool
功能：当前线程挂起，直到对应的 notify 函数被调用。
参数：
- condID：ConditionID 类型, 指定的条件变量
- timeout：Duration 类型，挂起时间，其默认值为
Duration.Max。
返回值：如果该 Monitor 指定的条件变量被其它线程唤醒，返回 true；如果超时，则返回 false
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，或者挂起时间超过
timeout或condID不是由该MultiConditionMonitor实例通过newCondition函数创建时，抛出异常 - IllegalArgumentException：如果
timeout <= Duration.Zero，抛出异常。
func notify
public func notify(condID: ConditionID): Unit
功能：唤醒等待在所指定的条件变量的线程（如果有）。
参数：
- condID：ConditionID 类型, 指定的条件变量
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，或
condID不是由该MultiConditionMonitor实例通过newCondition函数创建时，抛出异常。
func notifyAll
public func notifyAll(condID: ConditionID): Unit
功能：唤醒所有等待在所指定的条件变量的线程（如果有）。
参数：
- condID：ConditionID 类型, 指定的条件变量
异常：
- IllegalSynchronizationStateException：如果当前线程没有持有该互斥体，或
condID不是由该MultiConditionMonitor实例通过newCondition函数创建时，抛出异常。
class SyncCounter
public class SyncCounter {
public init(count: Int64)
}
SyncCounter 提供倒数计数器功能，线程可以等待计数器变为零。
init
public init(count: Int64)
功能：创建倒数计数器
参数：
- count：倒数计数器的初始值
异常：
- IllegalArgumentException：如果参数
count为负数
prop count
public prop count: Int64
功能：获取计数器的当前值
func dec
public func dec(): Unit
功能：计数器减一。如果计数器变为零，那么唤醒所有等待的线程；如果计数器已经为零，那么数值保持不变。
func waitUntilZero
public func waitUntilZero(timeout!: Duration = Duration.Max): Unit
功能：当前线程等待直到计数器变为零，或等待时间超过 timeout。
参数：
- timeout：阻塞时等待的最大时长，其默认值为
Duration.Max
class Barrier
public class Barrier {
public init(count: Int64)
}
Barrier 用于协调多个线程一起执行到某一个程序点。率先达到程序点的线程将进入阻塞状态，当所有线程都达到程序点后，才一起继续执行。
init
public init(count: Int64)
功能：创建 Barrier 对象。
参数：
- count：表示需要协调的线程数
异常：
- IllegalArgumentException：参数
count为负数
func wait
public func wait(timeout!: Duration = Duration.Max): Unit
功能：线程进入 Barrier 等待点。如果 Barrier 对象所有调用 wait 的次数（即进入等待点的线程数）等于初始值，那么唤醒所有等待的线程；如果调用 wait 方法次数仍小于初始值，那么当前线程进入阻塞状态直到被唤醒或者等待时间超过 timeout；如果调用 wait 次数已大于初始值，那么线程继续执行。
参数：
- timeout：阻塞时等待的最大时长，其默认值为
Duration.Max
异常：
- IllegalArgumentException：参数
count为负数
class Semaphore
public class Semaphore {
public init(count: Int64)
}
Semaphore 可以被视为携带计数器的 Monitor，常用于控制并发访问共享资源的线程数量。
init
public init(count: Int64)
功能：创建一个 Semaphore 对象并初始化内部计数器的值。
参数：
- count：计数器初始值
异常：
- IllegalArgumentException：参数
count为负数
prop count
public prop count: Int64
功能：返回当前内部计数器的值。
func acquire
public func acquire(amount!: Int64 = 1): Unit
功能：向 Semaphore 对象获取指定值，如果当前计数器小于要求的数值，那么当前线程将被阻塞，直到获取满足数量的值后才被唤醒。
参数：
- amount：向对象内部计数器中获取的数值，默认值为 1
异常：
- IllegalArgumentException：参数
amount为负数，或大于初始值
func tryAcquire
public func tryAcquire(amount!: Int64 = 1): Bool
功能：尝试向 Semaphore 对象获取指定值，该方法不会阻塞线程。如果有多个线程并发执行获取操作，则无法保证线程间的获取顺序。
参数：
- amount：向对象内部计数器中获取的数值，默认值为 1
返回值：如果当前计数器小于要求的数值，则获取失败并返回 false；成功获取值时返回 true。
异常：
- IllegalArgumentException：参数
amount为负数，或大于初始值
func release
public func release(amount!: Int64 = 1): Unit
功能：向 Semaphore 对象释放指定值。如果内部计数器在累加释放值后能够满足当前阻塞在 Semaphore 对象的线程，那么将得到满足的线程唤醒；内部计数器的值不会大于初始值，即如果计数器的值在累加后大于初始值，那么仍被设置为初始值。所有在调用 release 之前的操作都先发生于调用 acquire/tryAcquire 之后的操作。
参数：
- amount：向对象内部计数器中释放的数值，默认值为 1
返回值：如果当前计数器小于要求的数值，则获取失败并返回 false；成功获取值时返回 true。
异常：
- IllegalArgumentException：参数
amount为负数，或大于初始值
class ReentrantReadWriteMutex
public class ReentrantReadWriteMutex {
public init(mode!: ReadWriteMutexMode = ReadWriteMutexMode.Unfair)
}
ReentrantReadWriteMutex 是内置的可重入读写锁，它和普通互斥锁的差异在于：读写锁同时携带两个互斥锁，分别为“读锁”以及“写锁”，并且它允许多个线程同时持有读锁。读写锁有如下的特殊性质：
- 写互斥性：只有唯一的线程能够持有写锁。当一个线程持有写锁，而其他线程再次获取锁（读锁或是写锁）时将被阻塞。
- 读并发性：允许多个线程同时持有读锁。当一个线程持有读锁，其他线程仍然可以获取读锁。但其他线程获取写锁时将被阻塞。
- 可重入性：一个线程可以重复获取锁。
- 当线程已持有写锁时，它可以继续获取写锁或者读锁。只有当锁释放操作和获取操作一一对应时，锁才被完全释放。
- 当线程已持有读锁时，它可以继续获取读锁。当锁释放操作和获取操作一一对应时，锁才被完全释放。注意，不允许在持有读锁的情况下获取写锁，这将抛出异常。
- 锁降级：一个线程在经历“持有写锁--持有读锁--释放写锁”后，它持有的是读锁而不再是写锁。
- 读写公平性：读写锁支持两种不同的模式，分别为“公平”及“非公平”模式。
- 在非公平模式下，读写锁对线程获取锁的顺序不做任何保证。
- 在公平模式下，当线程获取读锁时（当前线程未持有读锁），如果写锁已被获取或是存在线程等待写锁，那么当前线程无法获取读锁并进入等待。
- 在公平模式下，写锁释放会优先唤醒所有读线程、读锁释放会优先唤醒一个等待写锁的线程。当存在多个线程等待写锁，他们之间被唤醒的先后顺序并不做保证。
init
public init(mode!: ReadWriteMutexMode = ReadWriteMutexMode.Unfair)
功能：构造读写锁。
参数：
- mod：读写锁模式；默认值为
Unfair，即构造“非公平”的读写锁
prop readMutex
public prop readMutex: ReentrantReadMutex
功能：获取读锁。
prop writeMutex
public prop writeMutex: ReentrantWriteMutex
功能：获取写锁。
enum ReadWriteMutexMode
public enum ReadWriteMutexMode {
| Unfair
| Fair
}
Unfair
Unfair
功能：读写锁非公平模式。
Fair
Unfair
功能：读写锁公平模式。
ReentrantReadMutex 和 ReentrantWriteMutex 分别是读锁和写锁类型，他们支持如下方法。
class ReentrantReadMutex
public class ReentrantReadMutex <: ReentrantMutex
ReentrantReadMutex 表示 ReentrantReadWriteMutex 中的读锁类型。
func lock
public func lock(): Unit
功能：获取读锁。
注意：
- 在公平模式下，如果没有其他线程持有或等待写锁，或是当前线程已持有读锁，则立即持有读锁；否则，当前线程进入等待状态。
- 在非公平模式下，如果没有其他线程持有或等待写锁，则立即持有读锁；如果有其他线程持有写锁，当前线程进入等待状态；否则，线程是否能立即持有读锁不做保证。
- 多个线程可以同时持有读锁并且一个线程可以重复多次持有读锁；如果一个线程持有写锁，那么它仍可以持有读锁。
func tryLock
public func tryLock(): Bool
功能：尝试获取读锁。该方法获取读锁时并不遵循公平模式。
返回值：若成功获取读锁，返回 true；若未能获取读锁，返回 false。
func unlock
public func unlock(): Unit
功能：释放读锁。如果一个线程多次持有读锁，那么仅当释放操作和获取操作数量相同时才释放读锁；如果读锁被释放并且存在线程等待写锁，那么唤醒其中一个线程。
异常：
- IllegalSynchronizationStateException：当前线程未持有读锁，那么将抛出异常。
class ReentrantWriteMutex
public class ReentrantWriteMutex <: ReentrantMutex
ReentrantWriteMutex 表示 ReentrantReadWriteMutex 中的写锁类型。
func lock
public func lock(): Unit
功能：获取写锁。只允许唯一线程能够持有写锁，且该线程能多次重复持有写锁。如果存在其他线程持有写锁或是读锁，那么当前线程进入等待状态。
异常：
- IllegalSynchronizationStateException：当前线程已持有读锁
func tryLock
public func tryLock(): Bool
功能：尝试获取写锁。该方法获取读锁时并不遵循公平模式。
返回值：若成功获取写锁，返回 true；若未能获取写锁，返回 false。
func unlock
public func unlock(): Unit
功能：释放写锁。
注意：
- 如果一个线程多次持有读锁，那么仅当释放操作和获取操作数量相同时才释放读锁；如果读锁被释放并且存在线程等待写锁，那么唤醒其中一个线程。
- 在公平模式下，如果写锁被释放并且存在线程等待读锁，那么优先唤醒这些等待线程；如果没有线程等待读锁，但存在线程等待写锁，那么唤醒其中一个线程。
- 在非公平模式下，如果写锁被释放，优先唤醒等待写锁的线程还是等待读锁的线程不做保证，交由具体实现决定。
异常：
- IllegalSynchronizationStateException：当前线程未持有写锁
class Timer
public class Timer <: Equatable<Timer>
Timer 表示定时器，用于在指定时间点或指定时间间隔后，执行指定任务一次或多次。
需要注意的是：
Timer隐式包含了spawn操作，即，每个Timer会创建一个线程用于执行该Timer关联的 Task。- 每个
Timer只能在初始化时绑定一个 Task，初始化完成后，无法重置关联的 Task。 - 只有关联 Task 执行完毕，或 使用
cancel接口主动取消Timer，Timer的生命周期才会结束，之后才能被 GC 回收。换句话说，在Timer关联的 Task 执行完毕或Timer被主动取消前，Timer实例均不会被 GC 回收，从而确保关联 Task 可以被正常执行。 - 系统繁忙时，Task 的触发时间可能会被影响。
Timer不保证 Task 的触发时间一定准时。Timer保证 Task 的触发时间小于等于当前时间时，会执行 Task，后续 Task 会被顺延。 Timer不会主动捕获关联 Task 抛出的异常。只要 Task 有未被捕获的异常，Timer就会失效。
func at
public static func at(dt: DateTime, task: () -> Option<Duration>): Timer
功能：初始化一个 Timer，关联的 Task 被调度执行的次数取决于它的返回值。如果定时器第一次触发的时间点小于当前时间，关联的 Task 会立刻被调度执行。如果关联 Task 的返回值为 Option.None，该 Timer 将会失效，并停止调度关联 Task。如果关联 Task 的返回值为 Option.Some(v) 且 v > Duration.Zero，下次运行前的最小时间间隔将被设置为 v。否则，关联 Task 会立刻再次被调度执行。
参数：
- dt：关联 Task 首次被调度执行的时间点
- task：该
Timer调度执行的 Task
返回值：一个 Timer 实例
异常：
- IllegalArgumentException：参数
dt晚于当前时间时，抛此异常
func after
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：从现在开始到关联 Task 首次被调度执行的时间间隔
- task：该
Timer调度执行的 Task
返回值：一个 Timer 实例
init
public init(start!: DateTime, task!: () -> Unit)
功能：初始化一个一次性 Timer，关联的 Task 只会被调度执行一次。如果参数 start 的时间点小于当前时间，关联的 Task 会立刻被调度执行。
参数：
- start：关联 Task 首次被调度执行的时间点
- task：该
Timer调度执行的 Task
异常：
- IllegalArgumentException：参数
start晚于当前时间，抛此异常
init
public init(start!: Duration, task!: () -> Unit)
功能：初始化一个一次性 Timer，关联的 Task 只会被调度执行一次。如果参数 start 的时间间隔为负值，关联的 Task 会立刻被调度执行。
参数：
- start：从现在开始到关联 Task 首次被调度执行的时间间隔
- task：该
Timer调度执行的 Task
init
public init(start!: DateTime, period!: Duration, task!: () -> Unit)
功能：初始化一个周期性 Timer，关联的 Task 只会被重复调度执行。如果参数 start 的时间点小于当前时间，关联的 Task 会立刻被调度执行。
参数：
- start：关联 Task 首次被调度执行的时间点
- period：关联 Task 两次执行的最小时间间隔
- task：该
Timer调度执行的 Task
异常：
- IllegalArgumentException：参数
start晚于当前时间，或period <= Duration.Zero时，抛此异常
init
public init(start!: Duration, period!: Duration, task!: () -> Unit)
功能：初始化一个周期性 Timer，关联的 Task 只会被重复调度执行。如果参数 start 的时间间隔为负值，关联的 Task 会立刻被调度执行。
参数：
- start：从现在开始到关联 Task 首次被调度执行的时间间隔
- period：关联 Task 两次执行的最小时间间隔
- task：该
Timer调度执行的 Task
异常：
- IllegalArgumentException：当
period <= Duration.Zero时，抛此异常
init
public init(start!: DateTime, end!: DateTime, period!: Duration, task!: () -> Unit)
功能：初始化一个周期性 Timer，关联的 Task 只会被重复调度执行。如果参数 start 的时间点小于当前时间，关联的 Task 会立刻被调度执行。
参数：
- start：关联 Task 首次被调度执行的时间点
- end：
Timer被取消，关联 Task 不再被调度执行的时间点 - period：关联 Task 两次执行的最小时间间隔
- task：该
Timer调度执行的 Task
异常：
- IllegalArgumentException：参数
start晚于当前时间，或参数end小于等于参数start或当前时间，或period <= Duration.Zero时，抛此异常
init
public init(start!: Duration, count!: Int64, period!: Duration, task!: () -> Unit)
功能：初始化一个周期性 Timer，关联的 Task 只会被重复调度执行。如果参数 start 的时间点小于当前时间，关联的 Task 会立刻被调度执行。
参数：
- start：从现在开始到关联 Task 首次被调度执行的时间间隔
- count：关联 Task 被调度执行的次数
- period：关联 Task 两次执行的最小时间间隔
- task：该
Timer调度执行的 Task
异常：
- IllegalArgumentException：当
count <= 0，或period <= Duration.Zero时，抛此异常
func cancel
public func cancel(): Unit
功能：取消该 Timer，关联 Task 将不再被调度执行。如果调用该函数时关联 Task 正在执行，不会打断当前运行。该函数不会阻塞当前线程。调用该函数多次等同于只调用一次。
operator func ==
public operator func ==(rhs: Timer): Bool
功能：判断当前 Timer 与入参 rhs 指定的 Timer 是否是同一个实例。
返回值：若两个 Timer 是同一个实例，则返回 true，否则返回 false
operator func !=
public operator func !=(rhs: Timer): Bool
功能：判断当前 Timer 与入参 rhs 指定的 Timer 是否不是同一个实例。
返回值：若两个 Timer 不是同一个实例，则返回 true，否则返回 false
func sleep
public func sleep(dur: Duration): Unit
功能：使得当前线程进入睡眠。若 dur <= Duration.Zero，当前线程会让出运行权。
参数：
- dur：线程睡眠的时长。
示例
Atomic 的使用
如何在多线程程序中，使用原子操作实现计数。
代码如下：
from std import sync.*
from std import time.*
from std import collection.*
let count = AtomicInt64(0)
main(): Int64 {
let list = ArrayList<Future<Int64>>()
/* 创建 1000 个线程 */
for (i in 0..1000) {
let fut = spawn {
sleep(Duration.millisecond) /* 睡眠 1 毫秒 */
count.fetchAdd(1)
}
list.append(fut)
}
/* 等待所有线程完成 */
for (f in list) {
f.get()
}
var val = count.load()
println("count = ${val}")
return 0
}
输出结果如下：
count = 1000
Monitor 的使用
下面是 Monitor 实例使用示例。
代码如下：
from std import sync.*
from std import time.{Duration, DurationExtension}
var mon = Monitor()
var flag: Bool = true
main(): Int64 {
let fut = spawn {
mon.lock()
while (flag) {
println("New thread: before wait")
mon.wait()
println("New thread: after wait")
}
mon.unlock()
}
/* 睡眠 10 毫秒，以确保新线程可以执行 */
sleep(10 * Duration.millisecond)
mon.lock()
println("Main thread: set flag")
flag = false
mon.unlock()
println("Main thread: notify")
mon.lock()
mon.notifyAll()
mon.unlock()
/* 等待新线程完成 */
fut.get()
return 0
}
输出结果如下：
New thread: before wait
Main thread: set flag
Main thread: notify
New thread: after wait
Timer 的使用
下面是 Timer 实例使用示例。
代码如下：
from std import sync.*
from std import time.{Duration, DurationExtension}
main(): Int64 {
let count = AtomicInt8(0)
Timer(start: 50 * Duration.millisecond, task: { =>
println("run only once")
count.fetchAdd(1)
})
let timer = Timer(start: 100 * Duration.millisecond, period: 200 * Duration.millisecond, task: { =>
println("run repetitively")
count.fetchAdd(10)
})
sleep(Duration.second)
timer.cancel()
sleep(500 * Duration.millisecond)
println("count = ${count.load()}")
0
}
输出结果如下：
run only once
run repetitively
run repetitively
run repetitively
run repetitively
run repetitively
count = 51