Swift 中 Actor、 AnyActor 、 MainActor 、GlobalActor 异同点 和 用法

在 Swift Concurrency 中，有几个与 Actor 相关的特性和协议，包括 Actor、AnyActor、MainActor 和 GlobalActor。它们都是用于并发编程和处理异步任务的特殊类型和特性。下面我们逐个介绍它们的异同点和用法：

Actor:

异同点：Actor 是用于实现并发编程的特殊类型。它使用 actor 关键字进行声明，包含一个私有队列，用于确保所有代码在该队列上串行执行。Actor 可以解决多线程环境下的数据竞争问题，提供更安全的数据访问和修改。
用法：你可以在需要线程安全的数据结构和代码块上声明 actor，以便将相关的操作封装在同一个执行上下文中，避免数据竞争。

AnyActor:

异同点：AnyActor 是一个用于类型擦除的协议，用于表示任意遵循 Actor 的类型。它可以在需要接收任意 Actor 类型的参数或存储属性时使用，类似于 Swift 中的 Any 类型。
用法：当你需要处理不确定具体 Actor 类型的实例时，可以使用 AnyActor 来进行类型擦除，从而消除类型限制。

MainActor:

异同点：MainActor 是一个全局 actor，它表示主线程的执行上下文。所有标记为 MainActor 的代码块都会在主线程上执行，这有助于确保主线程上的 UI 操作和其他重要任务在正确的线程上执行。
用法：在需要在主线程上执行代码时，可以使用 MainActor 来标记相关的函数或代码块。

GlobalActor:

异同点：GlobalActor 是一个用于自定义全局执行上下文的特性。你可以自定义一个遵循 GlobalActor 协议的执行器（Executor），并将相关代码块标记为在该全局执行上下文中执行。
用法：当需要在自定义的全局执行上下文中执行代码时，可以使用 GlobalActor 来标记相关的函数或代码块，并关联到你自定义的全局执行器

code

import Swift

// 定义一个 Actor 类
actor CounterActor {
    private var value = 0

    // Actor 的函数默认是非逃逸的
    func increment() {
        value += 1
    }

    // 使用 async 修饰，表示该函数是异步的
    func getValue() async -> Int {
        return value
    }
}

// 使用 AnyActor 对 Actor 进行类型擦除
func printActorValue(_ actor: AnyActor) {
    // 使用 async/await 来等待异步函数的结果
    Task {
        do {
            let value = try await actor.getValue()
            print("Actor 的值为：\(value)")
        } catch {
            print("获取 Actor 值时出错：\(error)")
        }
    }
}

// 使用 MainActor 来标记函数在主线程上执行
@MainActor
func updateUI() {
    // 更新 UI 操作
    print("UI 更新完成")
}

// 定义一个遵循 GlobalActor 协议的自定义执行器
class CustomExecutor: ConcurrentValue, GlobalActor {
    let globalExecutor = DispatchQueue(label: "custom-global-actor")
}

// 将函数标记为在自定义执行器上执行
@CustomExecutor
func performTaskOnCustomExecutor() {
    print("在自定义执行器上执行")
}

// 创建一个 Actor 实例
let counterActor = CounterActor()

// 异步执行 Actor 的函数
Task {
    counterActor.increment()
    let value = await counterActor.getValue()
    print("异步执行获取到的 Actor 值为：\(value)")
}

// 对 Actor 进行类型擦除
let anyActor: AnyActor = counterActor

// 调用类型擦除后的函数
printActorValue(anyActor)

// 在主线程上执行函数
updateUI()

// 在自定义执行器上执行函数
performTaskOnCustomExecutor()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

让我们通过一个简单的示例来说明使用 AnyActor 对 Actor 进行类型擦除的概念

import Swift

// 定义一个 Actor 类
actor CounterActor {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() async -> Int {
        return value
    }
}

// 使用 AnyActor 对 Actor 进行类型擦除
func printActorValue(_ actor: AnyActor) {
    // 使用 async/await 来等待异步函数的结果
    Task {
        do {
            // 使用 await 等待异步函数的结果
            let value = try await actor.getValue()
            print("Actor 的值为：\(value)")
        } catch {
            print("获取 Actor 值时出错：\(error)")
        }
    }
}

// 创建一个 Actor 实例
let counterActor = CounterActor()

// 异步执行 Actor 的函数
Task {
    counterActor.increment()
    let value = await counterActor.getValue()
    print("异步执行获取到的 Actor 值为：\(value)")
}

// 对 Actor 进行类型擦除
let anyActor: AnyActor = counterActor

// 调用类型擦除后的函数
printActorValue(anyActor)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46