Return to chapter index

5 Event-Based Programming

5.1 Events versus threads

5.2 Making actors event-based: react

  def buildChain(size: Int, next: Actor): Actor = {
    val a = actor {
      react {
        case 'Die =>
          val from = sender
          if (next != null) {
            next ! 'Die
            react {
              case 'Ack => from ! 'Ack
            }
          } else from ! 'Ack
      }
    }
    if (size > 0) buildChain(size - 1, a)
    else a
  }


  def main(args: Array[String]) {
    val numActors = args(0).toInt
    val start = System.currentTimeMillis
    buildChain(numActors, null) ! 'Die
    receive {
      case 'Ack =>
        val end = System.currentTimeMillis
        println("Took " + (end - start) + " ms")
    }
  }


actor {
  react {
    case "hello" =>
      println("hi")
  }
  println("finished")
}


actor {
  react {
    case "hello" =>
      println("hi")
      println("finished")
  }
}


def waitFor(n: Int): Unit = if (n > 0) {
  react {
    case 'Die =>
      val from = sender
      if (next != null) {
        next ! 'Die
        react {
          case 'Ack => from ! 'Ack; waitFor(n - 1)
        }
      } else { from ! 'Ack; waitFor(n - 1) }
  }
}


def sleep(delay: Long) {
  register(timer, delay, self)
  react { case 'Awake => /* OK, continue */ }
}


actor {
  val period = 1000
  {
    // code before going to sleep
    sleep(period)
  } andThen {
    // code after waking up
  }
}


  def buildChain(size: Int, next: Actor, lives: Int): Actor = {
    val a = actor {
      var n = lives
      loopWhile (n > 0) {
        n -= 1
        react {
          case 'Die =>
            val from = sender
            if (next != null) {
              next ! 'Die
              react { case 'Ack => from ! 'Ack }
            } else from ! 'Ack
        }
      }
    }
    if (size > 0) buildChain(size - 1, a, lives)
    else a
  }


  

5.3 Event-based futures

  def renderImages(url: String) {
    val imageInfos = scanForImageInfo(url)
    val dataFutures = for (info <- imageInfos) yield {
      val loader = actor {
        react { case Download(info) =>
          reply(info.downloadImage())
        }
      }
      loader !! Download(info)
    }
    for (i <- 0 until imageInfos.size) {
      dataFutures(i)() match {
        case data @ ImageData(_) => 
          renderImage(data)
      }
    }
    println("OK, all images rendered.")
  }


  def renderImages(url: String) {
    val imageInfos = scanForImageInfo(url)
    val dataFutures = for (info <- imageInfos) yield {
      val loader = actor {
        react { case Download(info) =>
          reply(info.downloadImage())
        }
      }
      loader !! Download(info)
    }
    var i = 0
    loopWhile (i < imageInfos.size) {
      i += 1
      dataFutures(i-1).inputChannel.react {
        case data @ ImageData(_) => renderImage(data)
      }
    } andThen { println("OK, all images rendered.") }
  }


  def renderImages(url: String) {
    val imageInfos = scanForImageInfo(url)
    val dataFutures = for (info <- imageInfos) yield {
      val loader = actor {
        react { case Download(info) =>
          reply(info.downloadImage())
        }
      }
      loader !! Download(info)
    }
    {
      for (ft <- ForEach(dataFutures)) {
        ft.inputChannel.react {
          case data @ ImageData(_) => renderImage(data)
        }
      } 
    } andThen {
      println("OK, all images rendered.")
    }
  }


  case class ForEach[T](iter: Iterable[T]) {
    def foreach(fun: T => Unit): Unit = {
      val it = iter.elements
      loopWhile (it.hasNext) {
        fun(it.next)
      }
    }
  }