类

class ArrayBlockingQueue<E>

public class ArrayBlockingQueue<E> {
    public init(capacity: Int64)
    public init(capacity: Int64, elements: Collection<E>)
}

功能：基于数组实现的 Blocking Queue 数据结构及相关操作函数。

ArrayBlockingQueue 是带阻塞机制且需要用户指定容量上界的并发队列。

prop size

public prop size: Int64

功能：返回此 ArrayBlockingQueue 的元素个数。

注意：

此方法不保证并发场景下的原子性，建议在环境中没有其它线程并发地修改 ArrayBlockingQueue 时调用。

类型：Int64

capacity

public let capacity: Int64

功能：此 ArrayBlockingQueue 的容量。

类型：Int64

init(Int64)

public init(capacity: Int64)

功能：构造一个带有传入容量大小的 ArrayBlockingQueue。

参数：

• capacity: Int64 - 初始化容量大小。

异常：

• IllegalArgumentException - 如果 capacity 小于等于 0 则抛出异常。

init(Int64, Collection<E>)

public init(capacity: Int64, elements: Collection<E>)

功能：构造一个带有传入容量大小，并带有传入迭代器的 ArrayBlockingQueue。

参数：

• capacity: Int64 - 初始化容量大小。
• elements: Collection<E> - 初始化迭代器元素。

异常：

• IllegalArgumentException - 如果 capacity 小于等于 0 或小于迭代器元素 elements 的 size 则抛出异常。

func dequeue()

public func dequeue(): E

功能：阻塞的出队操作，获得队首元素并删除。

返回值：

• E - 返回队首元素。

func dequeue(Duration)

public func dequeue(timeout: Duration): Option<E>

功能：阻塞的出队操作，获得队首元素并删除，如果队列为空，将等待指定的时间。如果 timeout 为负，则会立即执行出队操作并且返回操作结果。

参数：

• timeout: Duration - 等待时间。

返回值：

• Option<E> - 返回队首元素。如果超出等待时间还未成功获取队首元素，则返回 None。

func enqueue(E)

public func enqueue(element: E): Unit

功能：阻塞的入队操作，将元素添加到队列尾部。

参数：

• element: E - 要添加的元素。

func enqueue(E, Duration)

public func enqueue(element: E, timeout: Duration): Bool

功能：阻塞的入队操作，将元素添加到队列尾部，如果队列满了，将等待指定的时间。如果 timeout 为负，则会立即执行入队操作并且返回操作结果。

参数：

• element: E - 要添加的元素。
• timeout: Duration - 等待时间。

返回值：

• Bool - 成功添加元素返回 true，超出等待时间还未成功添加元素返回 false。

func head()

public func head(): Option<E>

功能：获取队首元素。

注意：

该函数是非阻塞的。

返回值：

• Option<E> - 返回队首元素，队列为空时返回 None。

func tryDequeue()

public func tryDequeue(): Option<E>

功能：非阻塞的出队操作，获得队首元素并删除。

返回值：

• Option<E> - 返回队首元素，队列为空时返回 None。

func tryEnqueue(E)

public func tryEnqueue(element: E): Bool

功能：非阻塞的入队操作，将元素添加到队列尾部。

参数：

• element: E - 要添加的元素。

返回值：

• Bool - 成功添加返回 true；如果队列满了，添加失败返回 false。

class BlockingQueue<E>

public class BlockingQueue<E> {
    public init()
    public init(capacity: Int64)
    public init(capacity: Int64, elements: Array<E>)
    public init(capacity: Int64, elements: Collection<E>)
}

功能：实现是带阻塞机制并支持用户指定容量上界的并发队列。

阻塞队列的特点是，当队列满时，尝试向队列中添加元素的线程会被阻塞，直到队列有空余位置；当队列空时，尝试从队列中获取元素的线程会被阻塞，直到队列有可取元素。

let capacity

public let capacity: Int64

功能：返回此 BlockingQueue 的容量。

类型：Int64

prop size

public prop size: Int64

功能：返回此 BlockingQueue 的元素个数。

注意：

此方法不保证并发场景下的原子性，建议在环境中没有其它线程并发地修改 BlockingQueue 时调用。

类型：Int64

init()

public init()

功能：构造一个具有默认初始容量 (Int64.Max) 的 BlockingQueue。

init(Int64)

public init(capacity: Int64)

功能：构造一个带有传入容量大小的 BlockingQueue。

参数：

• capacity: Int64 - 初始化容量大小。

异常：

• IllegalArgumentException - 如果 capacity 小于等于 0 则抛出异常。

init(Int64, Array<E>)

public init(capacity: Int64, elements: Array<E>)

功能：构造一个带有传入容量大小，并带有传入数组元素的 BlockingQueue。

参数：

• capacity: Int64 - 初始化容量大小。
• elements: Array<E> - 初始化数组元素。

异常：

• IllegalArgumentException - 如果 capacity 小于等于 0 或小于数组元素elements 的 size 则抛出异常。

init(Int64, Collection<E>)

public init(capacity: Int64, elements: Collection<E>)

功能：构造一个带有传入容量大小，并带有传入迭代器的 BlockingQueue。

参数：

• capacity: Int64 - 初始化容量大小。
• elements: Collection<E> - 初始化迭代器元素。

异常：

• IllegalArgumentException - 如果 capacity 小于等于 0 或小于迭代器元素elements 的 size 则抛出异常。

func dequeue()

public func dequeue(): E

功能：阻塞的出队操作，获得队首元素并删除。

返回值：

• E - 返回队首元素。

func dequeue(Duration)

public func dequeue(timeout: Duration): Option<E>

功能：阻塞的出队操作，获得队首元素并删除。如果队列为空，将等待指定的时间。如果 timeout 为负，则会立即执行出队操作并且返回操作结果。

参数：

• timeout: Duration - 等待时间。

返回值：

• Option<E> - 返回队首元素。如果超出等待时间还未成功获取队首元素，则返回 None。

func enqueue(E)

public func enqueue(element: E): Unit

功能：阻塞的入队操作，将元素添加到队列尾部。

参数：

• element: E - 要添加的元素。

func enqueue(E, Dureation)

public func enqueue(element: E, timeout: Duration): Bool

功能：阻塞的入队操作，将元素添加到队列尾部，如果队列满了，将等待指定的时间。如果 timeout 为负，则会立即执行入队操作并且返回操作结果。

参数：

• element: E - 要添加的元素。
• timeout: Duration - 等待时间。

返回值：

• Bool - 成功添加元素返回 true。超出等待时间还未成功添加元素返回 false。

func head()

public func head(): Option<E>

功能：获取队首元素。

注意：

该函数是非阻塞的。

返回值：

• Option<E> - 返回队首元素，队列为空时返回 None。

func tryDequeue()

public func tryDequeue(): Option<E>

功能：非阻塞的出队操作，获得队首元素并删除。

返回值：

• Option<E> - 返回队首元素，队列为空时返回 None

func tryEnqueue(E)

public func tryEnqueue(element: E): Bool

功能：非阻塞的入队操作，将元素添加到队列尾部。

参数：

• element: E - 要添加的元素。

返回值：

• Bool - 成功添加返回 true；如果队列满了，添加失败返回 false。

class ConcurrentHashMapIterator<K, V> where K <: Hashable & Equatable<K>

public class ConcurrentHashMapIterator<K, V> <: Iterator<(K, V)> where K <: Hashable & Equatable<K> {
    public init(cmap: ConcurrentHashMap<K, V>)
}

功能：此类主要实现 Concurrent HashMap 的迭代器功能。

注意：

这里定义的 Concurrent HashMap 迭代器：

1. 不保证迭代结果为并发 HashMap 某一时刻的 “快照”，建议在环境中没有其它线程并发地修改 Concurrent HashMap 时调用；
2. 迭代器在迭代过程中，不保证可以感知环境线程对目标 Concurrent HashMap 的修改。

init(ConcurrentHashMap<K, V>)

public init(cmap: ConcurrentHashMap<K, V>)

功能：创建 ConcurrentHashMapIterator<K, V> 实例。

参数：

• cmap: ConcurrentHashMap<K, V> - 待获取其迭代器的 ConcurrentHashMap<K, V> 实例。

func iterator()

public func iterator(): Iterator<(K, V)>

功能：获取 ConcurrentHashMap<K, V> 迭代器自身。

返回值：

• Iterator <(K, V) > - 迭代器自身。

func next()

public func next(): Option<(K, V)>

功能：返回迭代中的下一个元素。

返回值：

• Option <(K, V) > - Option<(K,V)> 类型。

class ConcurrentHashMap<K, V> where K <: Hashable & Equatable<K>

public class ConcurrentHashMap<K, V> <: ConcurrentMap<K, V> & Collection<(K, V)> where K <: Hashable & Equatable<K> {
    public init(concurrencyLevel!: Int64 = 16)
    public init(capacity: Int64, concurrencyLevel!: Int64 = 16)
    public init(elements: Collection<(K, V)>, concurrencyLevel!: Int64 = 16)
    public init(size: Int64, initElement: (Int64) -> (K, V), concurrencyLevel!: Int64 = 16)
}

功能：此类用于实现并发场景下线程安全的哈希表 ConcurrentHashMap 数据结构及相关操作函数。

当 ConcurrentHashMap 中出现键值对数量大于“桶”数量的情况时，会进行“扩容”。

构造函数中的参数 concurrencyLevel 表示“并发度”，即：最多允许多少个线程并发修改 ConcurrentHashMap。查询键值对的操作是非阻塞的，不受所指定的并发度 concurrencyLevel 的限制。参数 concurrencyLevel 默认等于 16。它只影响 ConcurrentHashMap 在并发场景下的性能，不影响功能。

注意：

如果用户传入的 concurrencyLevel 小于 16，则并发度会被设置为 16。

concurrencyLevel 并非越大越好，更大的 concurrencyLevel 会导致更大的内存开销（甚至可能导致 out of memory 异常），用户需要在内存开销和运行效率之间进行平衡。

使用示例：

使用示例见 ConcurrentHashMap 使用示例。

prop size

public prop size: Int64

功能：返回键值的个数。

注意：

此方法不保证并发场景下的原子性，建议在环境中没有其它线程并发地修改 ConcurrentHashMap 时调用。

类型：Int64

init(Collection<(K, V)>, Int64)

public init(elements: Collection<(K, V)>, concurrencyLevel!: Int64 = 16)

功能：构造一个带有传入迭代器和指定并发度的 ConcurrentHashMap。该构造函数根据传入迭代器元素 elements 的 size 设置 ConcurrentHashMap 的容量。

参数：

• elements: Collection<(K, V)> - 初始化迭代器元素。
• concurrencyLevel!: Int64 - 用户指定的并发度。

init(Int64)

public init(concurrencyLevel!: Int64 = 16)

功能：构造一个具有默认初始容量（16）和指定并发度（默认等于 16）的 ConcurrentHashMap。

参数：

• concurrencyLevel!: Int64 - 用户指定的并发度。

init(Int64, (Int64) -> (K, V), Int64)

public init(size: Int64, initElement: (Int64) -> (K, V), concurrencyLevel!: Int64 = 16)

功能：构造具有传入大小和初始化函数元素以及指定并发度的 ConcurrentHashMap。该构造函数根据参数 size 设置 ConcurrentHashMap 的容量。

参数：

• size: Int64 - 初始化函数元素的大小。
• initElement: (Int64) ->(K, V) - 初始化函数元素。
• concurrencyLevel!: Int64 - 用户指定并发度。

异常：

• IllegalArgumentException - 如果 size 小于 0 则抛出异常。

init(Int64, Int64)

public init(capacity: Int64, concurrencyLevel!: Int64 = 16)

功能：构造一个带有传入容量大小和指定并发度（默认等于 16）的 ConcurrentHashMap。

参数：

• capacity: Int64 - 初始化容量大小。
• concurrencyLevel!: Int64 - 用户指定的并发度。

异常：

• IllegalArgumentException - 如果 capacity 小于 0 则抛出异常。

func contains(K)

public func contains(key: K): Bool

功能：判断此映射中是否包含指定键 key 的映射。

参数：

• key: K - 传递要判断的 key。

返回值：

• Bool - 是否包含指定键 key 的映射。

func get(K)

public func get(key: K): ?V

功能：返回此映射中键 key 所关联的值。

参数：

• key: K - 传递 key，获取 value。

返回值:

• Option<V> - 此映射中键 key 所关联的值。

func isEmpty()

public func isEmpty(): Bool

功能：判断 ConcurrentHashMap 是否为空；如果是，则返回 true；否则，返回 false。

注意：

此方法不保证并发场景下的原子性，建议在环境中没有其它线程并发地修改 ConcurrentHashMap 时调用。

返回值：

• Bool - 如果是，则返回 true，否则，返回 false。

func iterator()

public func iterator(): ConcurrentHashMapIterator<K, V>

功能：获取 ConcurrentHashMap 的迭代器。

返回值：

• ConcurrentHashMapIterator < K, V > - Concurrent HashMap 的迭代器

func put(K, V)

public func put(key: K, value: V): ?V

功能：将指定的值 value 与此 Map 中指定的键 key 关联。如果 Map 中已经包含键 key 的关联，则旧值将被替换；如果 Map 中不包含键 key 的关联，则添加键 key 与值 value 的关联。

参数：

• key: K - 要放置的键。
• value: V - 要关联的值。

返回值：

• Option<V> - 如果赋值之前 key 存在，则返回旧的值 Some(v)；当赋值前 key 不存在时，返回 None。

func putIfAbsent(K, V)

public func putIfAbsent(key: K, value: V): ?V

功能：当此 Map 中不存在键 key 时，在 Map 中添加指定的值 value 与指定的键 key 的关联。如果 Map 已经包含键 key，则不执行赋值操作。

参数：

• key: K - 要放置的键。
• value: V - 要分配的值。

返回值：

• Option<V> - 如果赋值之前 key 存在，则返回当前 key 对应的值 Some(v)，且不执行赋值操作；当赋值前 key 不存在时，返回 None。

func remove((K, (V) -> Bool))

public func remove(key: K, predicate: (V) -> Bool): ?V

功能：如果此映射中存在键 key 且 key 所映射的值 v 满足条件 predicate，则从此映射中删除 key 的映射。

参数：

• key: K - 传入要删除的 key。
• predicate: (V) ->Bool - 传递一个 lambda 表达式进行判断。

返回值：

• Option<V> - 如果映射中存在 key，则返回 key 对应的旧值；当映射中不存在 key 时，或者 key 关联的值不满足 predicate 时，返回 None。

func remove(K)

public func remove(key: K): ?V

功能：从此映射中删除指定键 key 的映射（如果存在）。

参数：

• key: K - 传入要删除的 key。

返回值：

• Option<V> - 如果移除之前 key 存在，则返回 key 对应的值 Some(v)；当移除时 key 不存在时，返回 None。

func replace(K, (V) -> Bool, (V) -> V)

public func replace(key: K, predicate: (V) -> Bool, eval: (V) -> V): ?V

功能：如果 Map 中存在键 key（假设其关联的值为 v），且 v 满足条件 predicate，则将 Map 中键 key 关联的值替换为 eval(v) 的计算结果；如果 Map 中不存在键 key，或者存在键 key 但关联的值不满足 predicate，则不对 Map 做任何修改。 参数：

• key: K - 传入要替换所关联值的键。
• predicate: (V) ->Bool - 传递一个 lambda 表达式进行判断。
• eval: (V) ->V - 传入计算用于替换的新值的函数。

返回值：

• Option<V> - 如果 key 存在，则返回 key 对应的旧值 Some(V)；当 key 不存在时，或者 key 关联的值不满足 predicate 时，返回 None。

func replace(K, (V) -> V)

public func replace(key: K, eval: (V) -> V): ?V

功能：如果 Map 中存在键 key（假设其关联的值为 v），则将 Map 中键 key 关联的值替换为 eval(v) 的计算结果；如果 Map 中不存在键 key，则不对 Map 做任何修改。

参数：

• key: K - 传入要替换所关联值的键。
• eval: (V) ->V - 传入计算用于替换的新值的函数。

返回值：

• Option<V> - 如果 key 存在，则返回 key 对应的旧值 Some(V)；当 key 不存在时，返回 None。

func replace(K, V)

public func replace(key: K, value: V): ?V

功能：如果 Map 中存在 key，则将 Map 中键 key 关联的值替换为 value；如果 Map 中不存在 key，则不对 Map 做任何修改。

参数：

• key: K - 传入要替换所关联值的键。
• value: V - 传入要替换成的新值。

返回值：

• Option<V> - 如果 key 存在，则返回 key 对应的旧值 Some(v)；当 key 不存在时，返回 None。

operator func [](K)

public operator func [](key: K): V

功能：运算符重载集合，如果键存在，返回键对应的值；如果不存在，抛出异常。

参数：

• key: K - 传递值进行判断。

返回值：

• V - 与键对应的值。

异常：

• NoneValueException - 关联中不存在键 key。

operator func [](K, V)

public operator func [](key: K, value!: V): Unit

功能：运算符重载集合，如果键 key 存在，新 value 覆盖旧 value；如果键不存在，添加此键值对。

参数：

• key: K - 传递值进行判断。
• value!: V - 传递要设置的值。

class NonBlockingQueue<E>

public class NonBlockingQueue<E> {
    public init()
    public init(elements: Collection<E>)
}

功能：提供一个线程安全的队列，可以在多线程环境下安全地进行元素的添加和删除操作。

非阻塞队列的目的是为了解决多线程环境下的同步问题，使得多个线程可以并发地进行队列的操作，而不会出现数据冲突或者死锁的问题。

非阻塞队列在多线程编程中非常常见，它可以用于任何需要线程安全队列的场景，例如生产者消费者模型、任务调度、线程池等。

使用示例：

使用示例见 NonBlockingQueue 使用示例。

prop size

public prop size: Int64

功能：获取此 NonBlockingQueue 的元素个数。

注意：

此方法不保证并发场景下的原子性，建议在环境中没有其它线程并发地修改 NonBlockingQueue 时调用。

类型：Int64

init()

public init()

功能：构造一个默认的 NonBlockingQueue 实例。

init(Collection<E>)

public init(elements: Collection<E>)

功能：根据 Collection<E> 实例构造一个 NonBlockingQueue 实例。

参数：

• elements: Collection<E> - 将该容器中元素放入新构造的 NonBlockingQueue 实例中。

func dequeue()

public func dequeue(): Option<E>

功能：获取并删除队首元素。

返回值：

• Option<E> - 成功删除则返回队首元素，队列为空则返回 None。

func enqueue(E)

public func enqueue(element: E): Bool

功能：非阻塞的入队操作，将元素添加到队列尾部。

注意：

该函数不会返回 false。

参数：

• element: E - 要添加的元素。

返回值：

• Bool - 成功添加元素则返回 true。

func head()

public func head(): Option<E>

功能：获取队首元素，不会删除该元素。

返回值：

• Option<E> - 成功获取则返回队首元素，队列为空则返回 None。