如何从监督Actor终止渲染Actor内的位图绘制循环？

核心原则是让Actor主动支持任务中断，而非依赖Kill/Stop这类强制终止操作（它们会等待当前消息处理完成），同时遵循Actor异步通信的最佳实践（避免使用Ask）。具体实现方案如下：

1. 拆分长任务+中断标志位（单线程Actor内） #

如果渲染任务可以拆分为多个独立小步骤，可在Actor内部维护线程安全的中断标志，每完成一个小步骤就检查标志，判断是否终止任务：

• 给Actor定义自定义消息：StartRendering（启动渲染）和StopRendering（触发中断）。
• 用AtomicBoolean作为中断标志，收到StopRendering时将标志设为true。
• 渲染逻辑拆分小批次执行，每批次后检查标志，若为true则清理资源并退出当前消息处理。

示例代码（Scala）：

import akka.actor.{Actor, Props}
import java.util.concurrent.atomic.AtomicBoolean

object RenderActor {
  case class StartRendering(bitmap: Bitmap)
  case object StopRendering
}

class RenderActor extends Actor {
  private val shouldStop = new AtomicBoolean(false)
  import RenderActor._

  override def receive: Receive = {
    case StartRendering(bitmap) =>
      shouldStop.set(false)
      // 按1000像素为批次拆分渲染任务
      for (i <- 0 until bitmap.totalPixels by 1000) {
        if (shouldStop.get()) {
          bitmap.release() // 清理资源
          return
        }
        bitmap.drawBatch(i, 1000) // 执行小批次渲染
      }
    case StopRendering =>
      shouldStop.set(true)
  }
}

// 模拟位图类
class Bitmap(val totalPixels: Int) {
  def drawBatch(start: Int, count: Int): Unit = Thread.sleep(10) // 模拟耗时绘制
  def release(): Unit = {} // 释放资源逻辑
}

2. 异步任务+取消令牌（非阻塞Actor） #

如果渲染任务无法拆分或耗时极长，可将任务放到独立线程池执行，通过取消令牌中断任务，同时Actor保持非阻塞状态以响应中断消息：

• 使用CancellationTokenSource生成取消令牌，绑定到异步渲染任务。
• Actor收到StartRendering时提交任务到专用线程池，并持有任务和令牌的引用。
• 收到StopRendering时调用令牌的cancel()方法，任务内部定期检查令牌状态，实现中断。
• 通过Future.onComplete处理任务完成/取消后的状态清理。

示例代码（Scala）：

import akka.actor.{Actor, Props}
import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success}
import java.util.concurrent.atomic.AtomicReference
import scala.concurrent.CancellationException

object RenderActor {
  case class StartRendering(bitmap: Bitmap)
  case object StopRendering
}

class RenderActor(renderEc: ExecutionContext) extends Actor {
  import RenderActor._
  import scala.concurrent.ExecutionContext.Implicits.global

  private var currentTask: Option[(Future[Unit], CancellationTokenSource)] = None

  override def receive: Receive = {
    case StartRendering(bitmap) =>
      // 先取消现有任务（如果存在）
      currentTask.foreach { case (_, cts) => cts.cancel() }
      
      val cts = CancellationTokenSource()
      val renderTask = Future {
        for (i <- 0 until bitmap.totalPixels by 1000) {
          if (cts.isCancelled) {
            bitmap.release()
            throw new CancellationException("渲染任务已取消")
          }
          bitmap.drawBatch(i, 1000)
        }
      }(renderEc)

      // 处理任务结果
      renderTask.onComplete {
        case Success(_) => 
          println("渲染完成")
          currentTask = None
        case Failure(_: CancellationException) =>
          println("渲染已取消")
          currentTask = None
        case Failure(ex) =>
          println(s"渲染失败: ${ex.getMessage}")
          currentTask = None
      }
      currentTask = Some((renderTask, cts))

    case StopRendering =>
      currentTask.foreach { case (_, cts) => cts.cancel() }
  }
}

// 辅助类实现
class Bitmap(val totalPixels: Int) {
  def drawBatch(start: Int, count: Int): Unit = Thread.sleep(10)
  def release(): Unit = {}
}

class CancellationTokenSource {
  private val cancelled = new AtomicBoolean(false)
  def cancel(): Unit = cancelled.set(true)
  def isCancelled: Boolean = cancelled.get()
}

关键注意事项 #

• 避免使用Kill：会直接终止Actor，不执行任何清理逻辑，可能导致资源泄漏。
• 避免使用Stop：会等待当前消息处理完成后才终止Actor，无法中断正在执行的长任务。
• 禁用Ask：同步请求会破坏Actor的异步特性，改用Tell发送中断消息即可。

内容的提问来源于stack exchange，提问作者Attila Karoly