scala - ¿Alternativas a usar “var” para el estado con actores?

akka

Question

Me he encontrado usando vars bastante a menudo con actores akka para mantener el estado. Por ejemplo, si mi actor necesita mantener una lista de elementos, podría hacer algo como:

class ListActor extends Actor{
  var xs : List[Int] = List()

  def receive = {
    case x : Int => xs = x :: xs
  }
}

Usar la variable mutable parece ir en contra del espíritu de Scala. Alternativamente he usado esto:

class ListActor2 extends Actor{
  import context._

  def collect_ints(accu : List[Int]) : Receive = {
    case x : Int => become(collect_ints(x :: accu))
  }

  def receive = collect_ints(Nil)
}

Me gusta cómo se ve más, pero ¿tengo que preocuparme por el desbordamiento de la pila?

Soy consciente del rasgo FSM y lo he usado antes también, pero para algunas situaciones parece demasiado.

¿Cuál es la forma recomendada de mantener el estado simple? ¿Hay otras alternativas que desconozco?

Además, ¿es generalmente una mala señal si me encuentro que a menudo necesito variables mutables? ¿No estoy usando el modelo de actor correctamente?

Answer 1

El Akka FSM es en realidad un lenguaje muy compacto para mantener el estado en un sistema de actor como en este ejemplo:

sealed trait State
case object Active extends State

class ListActor extends Actor with FSM[State,List[Int]] {

  startWith(Active,List[Int]())

  when(Active) {
    case Event(x:Int,xs) => stay using x :: xs
  }
}

Habiendo usado todas las alternativas discutidas aquí, FSM toma mi voto por cualquier cosa que sea un tono más complejo que trivial.

Answer 2

Hay dos variantes del método become : una que empuja el comportamiento en una pila y otra que no lo hace. Este último es el predeterminado, por lo que no tiene que preocuparse por que la pila de comportamiento sea demasiado grande. El uso de become para administrar el estado de esta manera es un uso perfectamente válido para él.

Answer 3

No veo ningún problema con var para el estado simple en el modelo de actor.

Por diseño, Akka evita que el actor se corrompa o se bloquee por el acceso simultáneo a las variables de estado.

Mientras no exponga su estado a otros subprocesos con el uso de Future, por ejemplo , el uso de var para el estado simple no debería ser un problema.