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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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()

public init()

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

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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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 - 写入原子类型的值。

返回值:

func swap(UInt16, MemoryOrder)

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

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

参数:

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

返回值:

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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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 - 写入原子类型的值。

返回值:

func swap(UInt32, MemoryOrder)

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

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

参数:

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

返回值:

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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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 - 写入原子类型的值。

返回值:

func swap(UInt64, MemoryOrder)

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

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

参数:

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

返回值:

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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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

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

参数:

  • 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 - 表示需要协调的线程数。

异常:

func wait(Duration)

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

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

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

参数:

class Monitor

public class Monitor <: ReentrantMutex

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

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

父类型:

init()

public init()

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

func notify()

public func notify(): Unit

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

异常:

func notifyAll()

public func notifyAll(): Unit

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

异常:

func wait(Duration)

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

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

参数:

返回值:

  • Bool - 如果 Monitor 被其它线程唤醒,返回 true;如果超时,则返回 false

异常:

class MultiConditionMonitor

public class MultiConditionMonitor <: ReentrantMutex

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

注意:

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

父类型:

init()

public init()

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

func newCondition()

public func newCondition(): ConditionID

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

返回值:

异常:

func notify(ConditionID)

public func notify(condID: ConditionID): Unit

功能:唤醒等待在所指定的条件变量的线程(如果有)。

参数:

异常:

func notifyAll(ConditionID)

public func notifyAll(condID: ConditionID): Unit

功能:唤醒所有等待在所指定的条件变量的线程(如果有)。

参数:

异常:

func wait(ConditionID, Duration)

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

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

参数:

返回值:

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

异常:

class ReentrantMutex

public open class ReentrantMutex <: IReentrantMutex

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

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

注意:

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

父类型:

init()

public init()

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

异常:

func lock()

public open func lock(): Unit

功能:锁定互斥体,如果互斥体已被锁定,则阻塞。

func tryLock()

public open func tryLock(): Bool

功能:尝试锁定互斥体。

返回值:

  • Bool - 如果互斥体已被锁定,则返回 false;反之,则锁定互斥体并返回 true

func unlock

public open func unlock(): Unit

功能:解锁互斥体。

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

异常:

class ReentrantReadMutex

public class ReentrantReadMutex <: ReentrantMutex

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

父类型:

func lock()

public func lock(): Unit

功能:获取读锁。

注意:

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

func tryLock()

public func tryLock(): Bool

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

返回值:

  • Bool - 若成功获取读锁,返回 true;若未能获取读锁,返回 false

func unlock()

public func unlock(): Unit

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

异常:

class ReentrantReadWriteMutex

public class ReentrantReadWriteMutex

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

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

读写锁的特殊性质说明:

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

prop readMutex

public prop readMutex: ReentrantReadMutex

功能:获取读锁。

类型:ReentrantReadMutex

prop writeMutex

public prop writeMutex: ReentrantWriteMutex

功能:获取写锁。

类型:ReentrantWriteMutex

init(ReadWriteMutexMode)

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

功能:构造读写锁。

参数:

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

class ReentrantWriteMutex

public class ReentrantWriteMutex <: ReentrantMutex

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

父类型:

func lock()

public func lock(): Unit

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

异常:

func tryLock()

public func tryLock(): Bool

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

返回值:

  • Bool - 若成功获取写锁,返回 true;若未能获取写锁,返回 false

func unlock()

public func unlock(): Unit

功能:释放写锁。

注意:

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

异常:

class Semaphore

public class Semaphore

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

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

prop count

public prop count: Int64

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

类型:Int64

init(Int64)

public init(count: Int64)

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

参数:

异常:

func acquire(Int64)

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

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

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

参数:

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

异常:

func release(Int64)

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

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

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

参数:

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

返回值:

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

异常:

func tryAcquire(Int64)

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

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

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

参数:

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

返回值:

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

异常:

class SyncCounter

public class SyncCounter

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

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

prop count

public prop count: Int64

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

类型:Int64

init(Int64)

public init(count: Int64)

功能:创建倒数计数器。

参数:

异常:

func dec()

public func dec(): Unit

功能:计数器减一。

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

func waitUntilZero(Duration)

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

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

参数:

class Timer

public class Timer <: Equatable<Timer> & Hashable

功能:提供定时器功能。

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

注意:

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

父类型:

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

返回值:

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

异常:

示例:

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

异常:

示例:

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

异常:

示例:

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