移动端线程安全之Actor

用户9448393221345
2,478 阅读10分钟

Kotlin中的Actor介绍

Kotlin actor是Kotlin编程语言中一种用于构建并发和分布式应用程序的高级工具。它提供了一种基于Actor模型的并发模型，能够更加轻松地实现复杂的并发场景。

Actor模型是一种并发编程模型，其中系统中的每个组件都被建模为一个独立的Actor，这个Actor可以接收和发送消息，也可以对它的内部状态进行修改。这种模型对于处理异步消息非常有用，并且可以通过对Actor的组合来构建复杂的系统。

Kotlin actor库是基于此模型构建的。它提供了一种简单的方法来创建和管理Actor，并且通过使用协程作为底层机制来保证了Actor之间的异步通信。这种方法不仅能够简化编程模型，同时也可以实现更好的性能和可扩展性。

在Kotlin actor库中，每个Actor都由一个类来表示，并且可以通过创建Actor实例来启动Actor。一旦Actor被启动，它就会开始等待接收来自其他Actor的消息，并且可以根据接收到的消息做出相应的响应。当Actor需要发送消息时，它可以使用send方法向其他Actor发送消息。

Kotlin actor库还提供了一些额外的功能来帮助处理并发场景。例如，它可以支持Actor之间的超时和取消操作，这样可以更加灵活地处理Actor之间的通信。此外，Kotlin actor库还支持Actor之间的监督和层次关系，使得系统中的错误能够更加容易地处理。

Kotlin actor是Kotlin编程语言中一种非常强大的工具，它提供了一种简单而有效的方法来构建并发和分布式应用程序。如果您正在开发需要处理并发或异步消息的应用程序，那么Kotlin actor库可能是您的一个很好的选择。

Kotlin Actor的常用API

Kotlin Actor是基于协程机制实现的并发编程工具，提供了一系列的API来帮助开发者处理并发任务和消息传递。下面介绍一些常用的Kotlin Actor API：

  1. actor函数：创建一个Actor实例，并返回一个Actor的引用。可以通过这个引用向Actor发送消息，也可以通过这个引用进行Actor的取消操作。
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.actor

suspend fun main() {
    val actor = actor<Int>(Dispatchers.Default) {
        for (msg in channel) {
            println("Received message: $msg")
        }
    }

    actor.send(1)
    actor.send(2)
    actor.send(3)

    actor.close()
}

使用actor函数创建了一个Actor实例，并且向Actor发送了一些消息。在Actor中，我们可以通过channel来接收消息，并对消息进行处理。最后，我们通过调用close方法来关闭Actor实例。

  1. send方法：向Actor发送一个消息
val actor = actor<String>(Dispatchers.Default) {
    for (msg in channel) {
        println("Received message: $msg")
    }
}

actor.send("hello")
actor.send("world")

向一个Actor发送了两个字符串消息，这些消息将会被Actor接收并进行处理。

  1. close方法：关闭一个Actor实例。
val actor = actor<Int>(Dispatchers.Default) {
    for (msg in channel) {
        println("Received message: $msg")
    }
}

actor.close()

使用close方法关闭了一个Actor实例，这将会停止Actor的消息处理循环，并且释放Actor的资源。

使用范例

这里我们通过用Kotlin Actor实现一个支持优先级的消息队列，每条消息携带一个suspend函数来表示消费该消息需要执行的具体任务。

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.actor
import java.util.*

data class Message(val priority: Int, val content: String, val action: suspend () -> Unit)

fun main() = runBlocking<Unit> {
    val messageQueue = PriorityQueue<Message>(compareByDescending { it.priority })

    val actor = actor<Message>(Dispatchers.Default) {
        for (msg in channel) {
            messageQueue.offer(msg)
        }
    }

    // send messages to the queue with different priorities and actions
    actor.send(Message(1, "low priority message") { delay(1000); println("low priority action finished") })
    actor.send(Message(3, "high priority message") { delay(500); println("high priority action finished") })
    actor.send(Message(2, "medium priority message") { delay(750); println("medium priority action finished") })

    // execute the actions of the messages in priority order
    while (messageQueue.isNotEmpty()) {
        val message = messageQueue.poll()
        message.action()
    }

    actor.close()
}

首先定义了一个Message数据类，用来表示队列中的消息，包括消息的优先级和内容。然后我们创建了一个PriorityQueue实例，用来存储消息队列。接着我们使用actor函数创建了一个Actor实例，用来接收并处理消息。

我们在Message数据类中新增了一个suspend函数类型的action属性，用来表示消息的执行动作。在向Actor发送消息的时候，我们为每条消息指定了一个不同的action函数，并且在这个函数中进行了一些异步操作，比如使用delay函数来模拟一些耗时的操作。

在Actor中，我们将接收到的消息添加到消息队列中，然后我们通过遍历消息队列的方式按照优先级顺序执行队列中的消息的action函数，这样可以保证每条消息携带的suspend函数执行完成后，才表示这条消息被消费完成。

接下来，我们向Actor发送了三个不同优先级的消息，然后通过遍历消息队列的方式按照优先级顺序输出队列中的消息内容。

最后，通过调用close方法关闭了Actor实例

Swift中的Actor

Swift 5.5 引入了一个全新的 Actor 模型，用于解决 Swift 中多线程编程所遇到的诸多问题。同Kotlin中的Actor一样，Actor 是一种轻量级的并发原语，它将一组方法和属性封装在一个独立的运行时实体中，能够保证线程安全的同时，也提供了一些方便的并发操作。 在 Swift 中，Actor 被定义为一种类类型，使用 @actor 关键字进行修饰，当类的实例被创建时，就会生成一个 Actor 实例，所有访问该实例的方法都需要在 Actor 执行上下文中执行，以保证线程安全。

相比传统的锁和信号量等并发原语，Actor 更加容易使用，避免了很多共享资源的问题，并且能够更好地适应 Swift 中的异步编程模型。Actor 之间也可以互相通信，通过 async 和 await 关键字来进行异步消息传递和处理。

Swift Actor的常用API

Swift 中 Actor 常用的 API 包括：

  1. @ActorIndependent：一个属性修饰符，用于标识某个属性是 Actor 独立的，可以在 Actor 的外部线程中直接访问，不需要进行 async/await 调用。
  2. actor.receive()：在 Actor 内部，用于接收并处理来自其他 Actor 的消息。
  3. actor.async：在 Actor 内部，用于向其他 Actor 发送异步消息，返回一个 Task 对象，可以通过 await 关键字等待对应的响应。
  4. actor.isolated：在 Actor 内部，用于执行某些耗时的操作，但不会阻塞 Actor 的消息处理循环。

下面是一个简单的使用示例代码，展示了一个 Actor 接收和处理消息的过程：

@Actor class MyActor {
    var counter: Int = 0

    func receive(_ message: Int) {
        print("Received message: \(message)")
        counter += message
    }
}

let myActor = MyActor()

// 在 Actor 内部发送消息
myActor.async { actor in
    actor.receive(10)
}

// 在 Actor 外部访问 Actor 独立属性
print(myActor.@ActorIndependent.counter)

在上面的示例中，我们定义了一个 MyActor 类，并在其内部实现了 receive 方法，用于接收来自其他 Actor 的消息，并更新 counter 属性。在主线程中，我们创建了一个 MyActor 实例，并通过 async 方法向其发送一条消息。在 async 方法中，我们需要通过 actor 参数获取到 Actor 实例，以确保在 Actor 执行上下文中执行。最后，我们通过 @ActorIndependent 属性修饰符，在主线程中直接访问了 Actor 的独立属性 counter。

使用范例

我们同样通过Swift Actor实现一个支持优先级的消息队列，每条消息携带一个异步方法来表示消费该消息需要执行的具体任务。

import Foundation

@available(macOS 12.0, *)
actor MessageQueue {
    private var queue = PriorityQueue<Message>()

    func addMessage(_ message: Message) {
        queue.enqueue(message)
    }

    func processMessages() async {
        while let message = await queue.dequeue() {
            await message.action()
        }
    }
}

@available(macOS 12.0, *)
struct Message {
    let priority: Int
    let content: String
    let action: () async -> Void
}

@available(macOS 12.0, *)
func main() async {
    let messageQueue = MessageQueue()

    // send messages to the queue with different priorities and actions
    await messageQueue.addMessage(Message(priority: 1, content: "low priority message") { await Task.sleep(1); print("low priority action finished") })
    await messageQueue.addMessage(Message(priority: 3, content: "high priority message") { await Task.sleep(0.5); print("high priority action finished") })
    await messageQueue.addMessage(Message(priority: 2, content: "medium priority message") { await Task.sleep(0.75); print("medium priority action finished") })

    // execute the actions of the messages in priority order
    await messageQueue.processMessages()
}

Task {
    await main()
}

上面的代码中，我们首先定义了一个MessageQueue的Actor类，用来存储和处理消息队列。在MessageQueue中，我们使用了一个PriorityQueue来存储消息，并且提供了addMessage方法用来添加消息，以及processMessages方法用来按照优先级顺序执行消息队列中的异步函数。

然后我们定义了一个Message结构体，用来表示队列中的消息，包括消息的优先级、内容和异步执行函数。在向Actor发送消息的时候，我们为每条消息指定了一个不同的异步函数，并且在这个函数中进行了一些异步操作，比如使用Task.sleep函数来模拟一些耗时的操作。

在MessageQueue中，我们将接收到的消息添加到消息队列中，然后我们通过异步函数的方式按照优先级顺序执行队列中的消息的action函数，这样可以保证每条消息携带的异步函数执行完成后，才表示这条消息被消费完成。

相同和区别

Kotlin Actor 和 Swift Actor 作为两个不同语言中的 Actor 模型实现，它们有一些共同点和不同点：

相同点：

  1. 都是基于 Actor 模型的并发编程解决方案，可以实现线程安全的并发操作。
  2. 都支持异步消息传递和处理，可以通过 async 和 await 关键字等待对应的响应。
  3. 都提供了一些方便的 Actor 相关的 API，例如在 Actor 内部接收和处理消息，向其他 Actor 发送消息等。

不同点：

  1. 语言实现方式不同：Kotlin Actor 是基于协程实现的，而 Swift Actor 是基于异步函数实现的。
  2. Actor 的定义和声明方式不同：Kotlin 中 Actor 通过 actor 关键字进行修饰，Swift 中则是通过 @actor 关键字进行修饰。
  3. Actor 的实例化方式不同：在 Kotlin 中，Actor 是基于协程的，因此每个 Actor 实例都是一个协程，需要通过 actor() 方法来创建；而在 Swift 中，Actor 是基于异步函数的，因此每个 Actor 实例都是一个对象，需要通过类的初始化方法进行创建。
  4. 消息传递方式不同：在 Kotlin 中，可以通过 actor 的 send 方法向 Actor 发送消息，并通过 receive 方法接收并处理消息；而在 Swift 中，可以通过 async 方法向 Actor 发送异步消息，并通过 receive 方法接收和处理消息。

Actor和锁

在处理线程安全问题时，Actor机制和锁是我们常用的两类手段。Actor 模型相较于传统的锁机制具有以下优势：

  1. 减少锁竞争：传统的锁机制在多线程并发访问共享资源时，容易发生锁竞争，导致性能下降。而 Actor 模型中每个 Actor 都有自己的状态和消息队列，不会直接对共享资源进行访问，从而减少了锁竞争。
  2. 原子性操作：在 Actor 模型中，每个 Actor 的状态和消息队列只能被其自己访问，保证了原子性操作，避免了数据竞争和并发问题。
  3. 异步消息传递：Actor 模型通过异步消息传递的方式实现了线程安全的并发访问，从而避免了锁的等待和释放的开销。
  4. 可扩展性：Actor 模型可以实现高并发的场景，因为每个 Actor 都是独立的，可以运行在不同的线程或者不同的进程中，从而提高了系统的可扩展性。
  5. 简化编程：使用 Actor 模型可以将并发编程中的复杂性转化为消息传递的简单模型，避免了手动管理锁的复杂性，同时也简化了程序设计和维护的难度。

总体来说，相较于传统的锁机制，Actor 模型在处理线程安全方面具有更多的优势，可以提高系统的性能和可扩展性，同时也简化了并发编程的难度。然而，不同的并发场景和需求也可能需要不同的并发解决方案，需要根据具体情况进行选择。

avatar
文章
阅读
粉丝
相关推荐
听我一句劝，业务代码中，别用多线程。
50k阅读
 · 
347点赞
线程池不香了，结构化并发才是王道
36k阅读
 · 
342点赞
Swift MainActor 的使用教程
1.8k阅读
 · 
1点赞
iOS 线程安全和锁机制
2.6k阅读
 · 
12点赞
Rust使用axum结合Actor模型实现异步发送SSE
1.3k阅读
 · 
5点赞
Python中多线程和线程池的使用方法
9.7k阅读
 · 
10点赞
扒一扒抖音是如何做线程优化的
29k阅读
 · 
345点赞
美团动态线程池开源框架 DynamicTp
26k阅读
 · 
125点赞
Android性能优化-线程监控与线程统一
7.4k阅读
 · 
58点赞
Java CompletableFuture实现多线程异步编排
25k阅读
 · 
43点赞

友情链接：