类

class ArrayIterator<T>

public class ArrayIterator<T> <: Iterator<T> {
    public init(data: Array<T>)
}

功能：数组迭代器，迭代功能详述见 Iterable 和 Iterator 说明。

init(Array<T>)

public init(data: Array<T>)

功能：给定一个 Array 数组实例，创建其对应的迭代器，用来迭代遍历该数组实例中全部对象。

参数：

data: Array<T> - 数组实例。

func iterator()

public func iterator(): Iterator<T>

功能：获取当前迭代器实例本身。

返回值：

Iterator<T> - 当前迭代器实例本身。

func next()

public func next(): Option<T>

功能：返回数组迭代器中的下一个值。

返回值：

Option<T> - 数组迭代器中的下一个成员，用 Option 封装，迭代到末尾时返回 None。

class Box<T>

public class Box<T> {
    public var value: T
    public init(v: T)
}

功能：Box 类型提供了为其他类型添加一层 class 封装的能力。

如果 T 类型本身不具备引用能力，如 struct 类型，封装后 Box<T> 类型将可被引用。

var value

public var value: T

功能：获取或修改被包装的值。

类型：T

init(T)

public init(v: T)

功能：给定 T 类型实例，构造对应的 Box<T> 实例。

参数：

v: T - 任意类型实例。

extend<T> Box<T> <: Comparable<Box<T>> where T <: Comparable<T>

extend<T> Box<T> <: Comparable<Box<T>> where T <: Comparable<T>

功能：为 Box<T> 类扩展 Comparable<Box<T>> 接口，提供比较大小的能力。

Box<T> 实例的大小关系与其封装的 T 实例大小关系相同。

func compare(Box<T>)

public func compare(that: Box<T>): Ordering

功能：判断当前 Box 实例与另一个 Box 实例的大小关系。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Ordering - 如果当前 Box 实例大于 that，返回 Ordering.GT，等于返回 Ordering.EQ，小于返回 Ordering.LT。

operator func !=(Box<T>)

public operator func !=(that: Box<T>): Bool

功能：比较 Box 对象是否不相等。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象不等于参数 Box 对象返回 true，否则返回 false。

operator func <(Box<T>)

public operator func <(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象小于参数 Box 对象返回 true，否则返回 false。

operator func <=(Box<T>)

public operator func <=(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象小于等于参数 Box 对象返回 true，否则返回 false。

operator func ==(Box<T>)

public operator func ==(that: Box<T>): Bool

功能：比较 Box 对象是否相等。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象等于参数 Box 对象返回 true，否则返回 false。

operator func >(Box<T>)

public operator func >(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象大于参数 Box 对象返回 true，否则返回 false。

operator func >=(Box<T>)

public operator func >=(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

that: Box<T> - 比较的另外一个 Box 对象。

返回值：

Bool - 当前 Box 对象大于等于参数 Box 对象返回 true，否则返回 false。

extend<T> Box<T> <: Hashable where T <: Hashable

extend<T> Box<T> <: Hashable where T <: Hashable

func hashCode()

public func hashCode(): Int64

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

实际上该值为 Box 中封装的 T 类型实例的哈希值。

返回值：

Int64 - 当前 Box 对象的哈希值。

extend<T> Box<T> <: ToString where T <: ToString

extend<T> Box<T> <: ToString where T <: ToString

功能：为 Box<T> 类型扩展 ToString 接口，支持转字符串操作。

func toString()

public func toString(): String

功能：获取 Box 对象的字符串表示，字符串内容为当前实例封装的 T 类型实例的字符串表示。

返回值：

String - 转换后的字符串。

class Future<T>

public class Future<T>

功能：Future<T> 实例代表一个仓颉线程任务，可用于获取仓颉线程的计算结果，向仓颉线程发送取消信号。

spawn 表达式的返回类型是 Future<T>，其中 T 的类型取决于 spawn 表达式中的闭包的返回值类型。

prop thread

public prop thread: Thread

功能：获得对应仓颉线程的 Thread 实例。

类型：Thread

func cancel()

public func cancel(): Unit

功能：给当前 Future 实例对应的仓颉线程发送取消请求。该方法不会立即停止线程执行，仅发送请求，相应地，Thread 类的函数 hasPendingCancellation 可用于检查线程是否存在取消请求，用户可以通过该检查来自行决定是否提前终止线程以及如何终止线程。

func get()

public func get(): T

功能：阻塞当前线程，等待并获取当前 Future<T> 对象对应的线程的结果。

返回值：

T - 当前 Future<T> 实例代表的线程运行结束后的返回值。

func get(Int64)

public func get(ns: Int64): Option<T>

功能：阻塞当前线程，等待指定时长并获取当前 Future<T> 对象对应的线程的返回值。

需指定等待的超时时间，如果相应的线程在指定时间内未完成执行，则该函数将返回 None如果 ns <= 0，等同于 get()，即不限制等待时长。如果线程抛出异常退出执行，在 get 调用处将继续抛出该异常。

参数：

ns: Int64 - 等待时间，单位为纳秒。

返回值：

Option<T> - 返回指定时长后仓颉线程执行结果。

func tryGet()

public func tryGet(): Option<T>

功能：尝试获取执行结果，不会阻塞当前线程。如果相应的线程未完成，则该函数返回 None。

返回值：

Option<T> - 如果当前仓颉线程未完成返回 None，否则返回执行结果。

class Iterator<T>

public abstract class Iterator<T> <: Iterable<T>

功能：该类表示迭代器，提供 next 方法支持对容器内的成员进行迭代遍历。

func iterator()

public func iterator() : Iterator<T>

功能：返回迭代器自身。

返回值：

Iterator<T> - 迭代器自身。

func next()

public func next(): Option<T>

功能：获取迭代过程中的下一个元素。

返回值：

Option<T> - 迭代过程中的下一个元素。

extend<T> Iterator<T>

extend<T> Iterator<T>

功能：扩展 Iterator<T> 类型。

func all((T) -> Bool)

public func all(predicate: (T)-> Bool): Bool

功能：判断迭代器所有元素是否都满足条件。

参数：

predicate: (T) -> Bool - 给定的条件。

返回值：

Bool - 元素是否都满足条件。

func any((T) -> Bool)

public func any(predicate: (T)-> Bool): Bool

功能：判断迭代器是否存在任意一个满足条件的元素。

参数：

predicate: (T) -> Bool - 给定的条件。

返回值：

Bool - 是否存在任意满足条件的元素。

func at(Int64)

public func at(n: Int64): Option<T>

功能：获取当前迭代器第 n 个元素。

参数：

n: Int64 - 给定的个数。

返回值：

Option<T> - 返回对应位置元素，若 n 大于剩余元素数量则返回 None。

func concat(Iterator<T>)

public func concat(other: Iterator<T>): Iterator<T>

功能：串联两个迭代器，当前迭代器在先，参数表示的迭代器在后。

参数：

other: Iterator<T> - 要串联在后面的迭代器。

返回值：

Iterator<T> - 返回串联后的新迭代器。

func count()

public func count(): Int64

功能：统计当前迭代器包含元素数量。

返回值：

Int64 - 返回迭代器包含元素数量。

func enumerate()

public func enumerate(): Iterator<(Int64, T)>

功能：用于获取带索引的迭代器。

返回值：

Iterator <(Int64, T) > - 返回一个带索引的迭代器。

func filter((T) -> Bool)

public func filter(predicate: (T)-> Bool): Iterator<T>

功能：筛选出满足条件的元素。

参数：

predicate: (T) -> Bool - 给定的条件，条件为 true 的元素会按顺序出现在返回的迭代器里。

返回值：

Iterator<T> - 返回一个新迭代器。

func filterMap<R>((T) -> Option<R>)

public func filterMap<R>(transform: (T)-> Option<R>): Iterator<R>

功能：同时进行筛选操作和映射操作，返回一个新的迭代器。

参数：

transform: (T) -> Option<T> - 给定的映射函数。函数返回值为 Some 对应 filter 的 predicate 为 true，反之表示 false。

返回值：

Iterator<R> - 返回一个新迭代器。

func first()

public func first(): Option<T>

功能：获取当前迭代器的头部元素。

返回值：

Option<T> - 返回头部元素，若为空则返回 None。

func flatMap<R>((T) -> Iterator<R>)

public func flatMap<R>(transform: (T)-> Iterator<R>): Iterator<R>

功能：创建一个带 flatten 功能的映射。

参数：

transform: (T) -> Iterable<R> - 给定的映射函数。

返回值：

Iterator<R> - 返回一个带 flatten 功能的映射。

func fold<R>(R, (R, T) -> R)

public func fold<R>(initial: R, operation: (R, T)->R): R

功能：使用指定初始值，从左向右计算。

参数：

initial: R - 给定的 R 类型的初始值。
operation: (R, T) -> R - 给定的计算函数。

返回值：

R - 返回最终计算得到的值。

func forEach((T) -> Unit)

public func forEach(action: (T)-> Unit): Unit

功能：遍历当前迭代器所有元素，对每个元素执行给定的操作。

参数：

action: (T) -> Unit - 给定的操作函数。

func inspect((T) -> Unit)

public func inspect(action: (T) -> Unit): Iterator<T>

功能：迭代器每次调用 next() 对当前元素执行额外操作（不会消耗迭代器中元素）。

参数：

action: (T) -> Unit - 给定的操作函数。

返回值：

Iterator<T> - 返回一个新迭代器。

func isEmpty()

public func isEmpty(): Bool

功能：判断当前迭代器是否为空。

返回值：

Bool - 返回当前迭代器是否为空。

func last()

public func last(): Option<T>

功能：获取当前迭代器尾部元素。

返回值：

Option<T> - 返回尾部元素，若为空则返回 None。

func map<R>((T) -> R)

public func map<R>(transform: (T)-> R): Iterator<R>

功能：创建一个映射。

参数：

transform: (T) ->R - 给定的映射函数。

返回值：

Iterator<R> - 返回一个映射。

func none((T) -> Bool)

public func none(predicate: (T)-> Bool): Bool

功能：判断当前迭代器中所有元素是否都不满足条件。

参数：

predicate: (T) -> Bool - 给定的条件。

返回值：

Bool - 当前迭代器中元素是否都不满足条件。

func reduce((T, T) -> T)

public func reduce(operation: (T, T) -> T): Option<T>

功能：使用第一个元素作为初始值，从左向右计算。

参数：

initial: R - 给定的 R 类型的初始值。

返回值：

Option<T> - 返回计算结果。

func skip(Int64)

public func skip(count: Int64): Iterator<T>

功能：从前往后从当前迭代器跳过特定个数。

当 count 小于 0 时，抛异常。当 count 等于 0 时，相当没有跳过任何元素，返回原迭代器。当 count 大于0并且count小于迭代器的大小时，跳过 count 个元素后，返回含有剩下的元素的新迭代器。当 count 大于等于迭代器的大小时，跳过所有元素，返回空迭代器。

参数：

count: Int64 - 要跳过的个数。

返回值：

Iterator<T> - 返回一个跳过指定数量元素的迭代器。

异常：

IllegalArgumentException - 当 count < 0 时，抛出异常。

func step(Int64)

public func step(count: Int64): Iterator<T>

功能：迭代器每次调用 next() 跳过特定个数。

当 count 小于等于 0 时，抛异常。当 count 大于 0 时，每次调用 next() 跳过 count 次，直到迭代器为空。

参数：

count: Int64 - 每次调用 next() 要跳过的个数。

返回值：

Iterator<T> - 返回一个新迭代器，这个迭代器每次调用 next() 会跳过特定个数。

异常：

IllegalArgumentException - 当 count <= 0 时，抛出异常。

func take(Int64)

public func take(count: Int64): Iterator<T>

功能：从当前迭代器取出特定个数。

从后往前取出当前迭代器特定个数的元素。当 count 小于 0 时，抛异常。当 count 等于 0 时，不取元素，返回空迭代器。当 count 大于 0 小于迭代器的大小时，取前 count 个元素，返回新迭代器。当 count 大于等于迭代器的大小时，取所有元素，返回原迭代器。

参数：

count: Int64 - 要取出的个数。

返回值：

Iterator<T> - 返回一个取出指定数量元素的迭代器。

异常：

IllegalArgumentException - 当 count < 0 时，抛出异常。

func zip<R>(Iterator<R>)

public func zip<R>(it: Iterator<R>): Iterator<(T, R)>

功能：将两个迭代器合并成一个（长度取决于短的那个迭代器）。

参数：

other: Iterable<R> - 要合并的其中一个迭代器。

返回值：

Iterator <(T, R)> - 返回一个新迭代器。

extend<T> Iterator<T> where T <: Comparable<T>

extend<T> Iterator<T> where T <: Comparable<T>

功能：为 Iterator<T> 类型扩展 Comparable<T> 接口，支持比较操作。

func max()

public func max(): Option<T>

功能：筛选最大的元素。

返回值：

Option<T> - 返回最大的元素，若为空则返回 None。

func min()

public func min(): Option<T>

功能：筛选最小的元素。

返回值：

Option<T> - 返回最小的元素，若为空则返回 None。

extend<T> Iterator<T> where T <: Equatable<T>

extend<T> Iterator<T> where T <: Equatable<T>

功能：为 Iterator<T> 类型扩展扩展 Equatable<T> 接口，支持判等操作。

func contains(T)

public func contains(element: T): Bool

功能：遍历所有元素，判断是否包含指定元素。

参数：

element: T - 要查找的元素。

返回值：

Bool - 是否包含指定元素。

class Object

public open class Object <: Any {
    public const init()
}

Object 是所有 class 的父类，所有 class 都默认继承它。Object 类中不包含任何成员，即 Object 是一个“空”的类。

init()

public const init()

功能：构造一个 object 实例。

class RangeIterator<T> <: Iterator<T> where T <: Countable<T> & Comparable<T> & Equatable<T>

public class RangeIterator<T> <: Iterator<T> where T <: Countable<T> & Comparable<T> & Equatable<T>

功能：Range 类型的迭代器，迭代功能详述见 Iterable 和 Iterator 接口说明。

func iterator()

public func iterator(): Iterator<T>

功能：获取当前迭代器实例。

返回值：

Iterator<T> - 当前迭代器实例。

func next()

public func next(): Option<T>

功能：获取 Range 迭代器中的下一个值。

返回值：Range 迭代器中的下一个成员，用 Option 封装，迭代到末尾时返回 None。

class StackTraceElement

public open class StackTraceElement {
    public let declaringClass: String
    public let methodName: String
    public let fileName: String
    public let lineNumber: Int64
    public init(declaringClass: String, methodName: String, fileName: String, lineNumber: Int64)
}

功能：表示一个异常堆栈的具体信息，包括异常发生的类名、函数名、文件名、行号。

let declaringClass

public let declaringClass: String

功能：获取异常发生的类名。

类型：String

let fileName

public let fileName: String

功能：获取异常发生的文件名。

类型：String

let lineNumber

public let lineNumber: Int64

功能：获取异常发生的行号。

类型：Int64

let methodName

public let methodName: String

功能：获取异常发生的函数名。

类型：String

init(String, String, String, Int64)

public init(declaringClass: String, methodName: String, fileName: String, lineNumber: Int64)

功能：构造一个异常堆栈实例，指定类名、函数名、文件名、行号。

参数：

declaringClass: String - 类名。
methodName: String - 函数名。
fileName: String - 文件名。
lineNumber: Int64 - 行号。

class StringBuilder

public class StringBuilder <: ToString {
    public init()
    public init(str: String)
    public init(r: Rune, n: Int64)
    public init(value: Array<Rune>)
    public init(capacity: Int64)
}

功能：该类主要用于字符串的构建。

StringBuilder 在字符串的构建上效率高于 String：

在功能上支持传入多个类型的值，该类将自动将其转换为 String 类型对象，并追加到构造的字符串中。
在性能上使用动态扩容算法，减少内存申请频率，构造字符串的速度更快，占用内存资源通常更少。

注意：

StringBuilder 仅支持 UTF-8 编码的字符数据。

prop capacity

public prop capacity: Int64

功能：获取 StringBuilder 实例此时能容纳字符串的长度，该值会随扩容的发生而变大。

类型：Int64

prop size

public prop size: Int64

功能：获取 StringBuilder 实例中字符串长度。

类型：Int64

init()

public init()

功能：构造一个初始容量为 32 的空 StringBuilder 实例。

init(Array<Rune>)

public init(value: Array<Rune>)

功能：使用参数 value 指定的字符数组初始化一个 StringBuilder 实例，该实例的初始容量为 value 大小，初始内容为 value 包含的字符内容。

参数：

value: Array<Rune> - 初始化 StringBuilder 实例的字符数组。

init(Int64)

public init(capacity: Int64)

功能：使用参数 capacity 指定的容量初始化一个空 StringBuilder 实例，该实例的初始容量为 value 大小，初始内容为若干 \0 字符。

参数：

capacity: Int64 - 初始化 StringBuilder 的字节容量，取值范围为 (0, Int64.Max]。

异常：

IllegalArgumentException - 当参数 capacity 的值小于等于 0 时，抛出异常。

init(Rune, Int64)

public init(r: Rune, n: Int64)

功能：使用 n 个 r 字符初始化 StringBuilder 实例，该实例的初始容量为 n，初始内容为 n 个 r 字符。

参数：

r: Rune - 初始化 StringBuilder 实例的字符。
n: Int64 - 字符 r 的数量，取值范围为 [0, Int64.Max]。

异常：

IllegalArgumentException - 当参数 n 小于 0 时，抛出异常。

init(String)

public init(str: String)

功能：根据指定初始字符串构造 StringBuilder 实例，该实例的初始容量为指定字符串的大小，初始内容为指定字符串。

参数：

str: String - 初始化 StringBuilder 实例的字符串。

func append(Array<Rune>)

public func append(runeArr: Array<Rune>): Unit

功能：在 StringBuilder 末尾插入一个 Rune 数组中所有字符。

参数：

runeArr: Array<Rune> - 插入的 Rune 数组。

func append<T>(Array<T>) where T <: ToString

public func append<T>(val: Array<T>): Unit where T <: ToString

功能：在 StringBuilder 末尾插入参数 val 指定的 Array<T> 的字符串表示，类型 T 需要实现 ToString 接口。

参数：

val: Array<T> - 插入的 Array<T> 类型实例。

func append(Bool)

public func append(b: Bool): Unit

功能：在 StringBuilder 末尾插入参数 b 的字符串表示。

参数：

b: Bool - 插入的 Bool 类型的值。

func append(CString)

public func append(cstr: CString): Unit

功能：在 StringBuilder 末尾插入参数 cstr 指定 CString 中的内容。

参数：

cstr: CString - 插入的 CString。

func append(Float16)

public func append(n: Float16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Float16 - 插入的 Float16 类型的值。

func append(Float32)

public func append(n: Float32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Float32 - 插入的 Float32 类型的值。

func append(Float64)

public func append(n: Float64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Float64 - 插入的 Float64 类型的值。

func append(Int16)

public func append(n: Int16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Int16 - 插入的 Int16 类型的值。

func append(Int32)

public func append(n: Int32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Int32 - 插入的 Int32 类型的值。

func append(Int64)

public func append(n: Int64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Int64 - 插入的 Int64 类型的值。

func append(Int8)

public func append(n: Int8): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: Int8 - 插入的 Int8 类型的值。

func append(Rune)

public func append(r: Rune): Unit

功能：在 StringBuilder 末尾插入参数 r 指定的字符。

参数：

r: Rune - 插入的字符。

func append(String)

public func append(str: String): Unit

功能：在 StringBuilder 末尾插入参数 str 指定的字符串。

参数：

str: String - 插入的字符串。

func append(StringBuilder)

public func append(sb: StringBuilder): Unit

功能：在 StringBuilder 末尾插入参数 sb 指定的 StringBuilder 中的内容。

参数：

sb: StringBuilder - 插入的 StringBuilder 实例。

func append<T>(T) where T <: ToString

public func append<T>(v: T): Unit where T <: ToString

功能：在 StringBuilder 末尾插入参数 v 指定 T 类型的字符串表示，类型 T 需要实现 ToString 接口。

参数：

v: T - 插入的 T 类型实例。

func append(UInt16)

public func append(n: UInt16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: UInt16 - 插入的 UInt16 类型的值。

func append(UInt32)

public func append(n: UInt32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: UInt32 - 插入的 UInt32 类型的值。

func append(UInt64)

public func append(n: UInt64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: UInt64 - 插入的 UInt64 类型的值。

func append(UInt8)

public func append(n: UInt8): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

n: UInt8 - 插入的 UInt8 类型的值。

func appendFromUtf8(Array<Byte>)

public func appendFromUtf8(arr: Array<Byte>): Unit

功能：在 StringBuilder 末尾插入参数 arr 指向的字节数组。

该函数要求参数 arr 符合 UTF-8 编码，如果不符合，将抛出异常。

参数：

arr: Array<Byte> - 插入的字节数组。

异常：

IllegalArgumentException - 当字节数组不符合 utf8 编码规则时，抛出异常。

func appendFromUtf8Unchecked(Array<Byte>)

public unsafe func appendFromUtf8Unchecked(arr: Array<Byte>): Unit

功能：在 StringBuilder 末尾插入参数 arr 指向的字节数组。

相较于 appendFromUtf8 函数，它并没有针对于字节数组进行 UTF-8 相关规则的检查，所以它所构建的字符串并不一定保证是合法的，甚至出现非预期的异常，如果不是某些场景下的速度考虑，请优先使用安全的 appendFromUtf8 函数。

参数：

arr: Array<Byte> - 插入的字节数组。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：将 StringBuilder 扩容 additional 大小。

当 additional 小于等于零，或剩余容量大于等于 additional 时，不发生扩容；当剩余容量小于 additional 时，扩容至当前容量的 1.5 倍（向下取整）与 size + additional 的最大值。

参数：

additional: Int64 - 指定 StringBuilder 的扩容大小。

func reset(?Int64)

public func reset(capacity!: Option<Int64> = None): Unit

功能：清空当前 StringBuilder，并将容量重置为 capacity 指定的值。

参数：

capacity!: Option<Int64> - 重置后 StringBuilder 实例的容量大小，取值范围为 None 和 (Some(0), Some(Int64.Max)]，默认值 None 表示采用默认大小容量（32）。

异常：

IllegalArgumentException - 当参数 capacity 的值小于等于 0 时，抛出异常。

func toString()

public func toString(): String

功能：获取 StringBuilder 实例中的字符串。

注意：

该函数不会将字符串数据进行拷贝。

返回值：

String - StringBuilder 实例中的字符串。

class Thread

public class Thread

功能：Thread 类代表一个仓颉类，可用于获取线程 ID 及名字、查询线程是否存在取消请求、注册线程未处理异常的处理函数等。

该类型实例无法通过构造得到，仅能通过 Future 对象的 thread 属性或是 Thread 类的 currentThread 静态属性获取。

static prop currentThread

public static prop currentThread: Thread

功能：获取当前执行线程的 Thread 对象。

类型：Thread

prop hasPendingCancellation

public prop hasPendingCancellation: Bool

功能：线程是否存在取消请求，即是否通过 future.cancel() 发送过取消请求，常见使用方为 Thread.currentThread.hasPendingCancellation。

类型：Bool

prop id

public prop id: Int64

功能：获取当前执行线程的标识，以 Int64 表示，所有存活的线程都有不同标识，但不保证当线程执行结束后复用它的标识。

类型：Int64

prop name

public mut prop name: String

功能：获取或设置线程的名称，获取设置都具有原子性。

类型：String

func handleUncaughtExceptionBy((Thread, Exception) -> Unit)

public static func handleUncaughtExceptionBy(exHandler: (Thread, Exception) -> Unit): Unit

功能：注册线程未处理异常的处理函数。

当某一线程因异常而提前终止后，如果全局的未处理异常函数被注册，那么将调用该函数并结束线程，在该函数内抛出异常时，将向终端打印提示信息并结束线程，但不会打印异常调用栈信息；如果没有注册全局异常处理函数，那么默认会向终端打印异常调用栈信息。

多次注册处理函数时，后续的注册函数将覆盖之前的处理函数。

当有多个线程同时因异常而终止时，处理函数将被并发执行，因而开发者需要在处理函数中确保并发正确性。

处理函数的参数第一个参数类型为 Thread，是发生异常的线程，第二个参数类型为 Exception，是线程未处理的异常。

参数：

exHandler: (Thread, Exception) -> Unit - 注册的处理函数。

class ThreadLocal<T>

public class ThreadLocal<T>

功能：该类表示仓颉线程局部变量。

和普通变量相比，线程局部变量有不同的访问语义。当多个线程共享使用同一线程局部变量时，每个线程都有各自的一份值拷贝。线程对变量的访问会读写线程本地的值，而不会影响其他线程中变量的值。

func get()

public func get(): ?T

功能：获得仓颉线程局部变量的值。

返回值：

?T - 如果当前线程局部变量不为空值，返回该值，如果为空值，返回 None。

func set(?T)

public func set(value: ?T): Unit

功能：通过 value 设置仓颉线程局部变量的值，如果传入 None，该局部变量的值将被删除，在线程后续操作中将无法获取。

参数：

value: ?T - 需要设置的局部变量的值。

仓颉语言库 API