Scala并发编程

scala支持Java的多线程模型, 也继承了多线程固有的资源竞争和死锁问题.

作为一种函数式编程语言, scala的actor消息模型提供了一种更便捷更安全的并发编程方案.

线程模型

scala的线程模型来自于Java. 首先我们要拓展一个Runable或Callable, 并重写run方法

trait Runnable {
  def run(): Unit
}

Callable与Runable类似，但是有一个返回值:

trait Callable[V] {
  def call(): V
}

Thread需要一个Runable实例作为参数来创建:

scala> val thread = new Thread(new Runnable {
     |   def run() {
     |     println("hello world")
     |   }
     | })
thread: Thread = Thread[Thread-2,5,main]

scala> thread.start()
hello world

线程同步

synchronized是JVM中最简单的使用互斥锁的方式:

class User {
  var name: String = "";
  def setName(nameArg :String) {
    this.synchronized {
      this.name = nameArg;
    }
  }
}

当线程开始执行obj.synchronized块中的代码前, 它将尝试获得对象obj的锁, 若获取失败则线程进入阻塞状态.

当某个线程获得了对象的锁后, 其它线程就无法访问或修改该对象. 当obj.synchronized块中的代码执行完成时, 线程会解除锁, 另一个线程就可以加锁并访问对象了.

Future模型

scala提供了Promise-Future-Callback异步模型:

• Future 表示一个还没有完成的任务的结果, Future对象可以在任务完成前访问

• Promise 表示一个还没有执行的任务, 可以通过Promise标记任务的状态

• Callback 回调用于在任务完成或其它情况下执行的操作

Future

import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

object FutureDemo extends App {

  val f = Future {
    println("working on future task")
    Thread.sleep(100)
    1+1
  }
  
  println("waiting for future task complete")
  val result = Await.result(f, 1 second)
  println(result)
}

执行异步任务需要上下文, ExecutionContext.Implicits.global是使用当前的全局上下文作为隐式上下文.

引入.duration._允许我们使用1 second, 200 milli, 2 minute这样的时间间隔字面值.

上述示例中Await.result使用阻塞的方式等待Future任务完成, 若Future超时未完成则抛出TimeoutException异常.

多次运行上述示例就会发现, 两条提示输出顺序是不确定的. 这是因为Future中的代码是在独立线程中执行的.

更好的方式是采用回调的方式来处理Future结果:

import scala.concurrent.{Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object FutureDemo2 extends App {

  val f = Future {
    1 + 2
  }

  
  f.onComplete{
    case Success(value) => println(value)
    case Failure(e) => e.printStackTrace
  }

}

或者定义onSuccess和onFailure两个回调.

import scala.concurrent.{Future}
import scala.concurrent.ExecutionContext.Implicits.global

object FutureDemo2 extends App {

  val f = Future {
    1 + 2
  }

  
  f.onSuccess {
    case value => println(value)
  }

  f.onFailure {
    case e => e.printStackTrace
  }

}

Actor模型

Actor是一个基于消息机制的并发模型, 自Scala 2.11之后Akka Actor已成为Scala事实上的Actor标准.

akka不是scala的默认包, 这里我们使用SBT来管理外部包依赖. 关于sbt的使用可以参见作者的另一篇博文Scala构建工具SBT.

在build.sbt中添加下列代码, 引入akka依赖.

scalaVersion := "2.12.1"

resolvers += "Typesafe Repository" at "http://repo.typesafe.com/typesafe/releases/"

libraryDependencies +=
  "com.typesafe.akka" %% "akka-actor" % "2.4.17"

更多关于引入akka的内容可以参见akka官网.

import akka.actor.Actor
import akka.actor.ActorSystem
import akka.actor.Props

class HelloActor extends Actor {
  def receive() = {
    case "hello" => println("Hi, I am an actor.");
    case _       => println("?");
  }
}

object Main extends App {
  val system = ActorSystem("HelloSystem");
  val helloActor = system.actorOf(Props[HelloActor], name = "helloactor");
  helloActor ! "hello";
  helloActor ! "bye";
  system.shutdown();
}

自定义类继承Actor并重写receive方法处理不同类型的消息. 这里使用String类进行模式匹配, 使用case class进行模式匹配可以传递更多信息.

Actor需要ActorSystem的事件循环提供支持, 初始化一个ActorSystem后事件循环开始运行.最后必须执行system.shutdown();否则scala程序会一直运行下去.

!是用于发送消息的操作符, helloActor ! "hello";将消息"hello"发送给了helloActor.

receive方法的返回值类型是PartialFunction[Any, Unit]. 所有发送给Actor的消息都将被receive返回的偏函数处理.

偏函数的返回值类型为Unit, 也就是说处理消息时必须依赖副作用而不能有返回值; 偏函数的参数类型为Any, 也就是说所有消息在传入的时候都会发生类型丢失.

非类型化的消息便于设计消息转发, 负载均衡和代理Actor等机制, 且因为基于模式匹配的消息处理, 非类型化并不会产生问题.

基于事件循环的非阻塞机制已经被广为使用, 这里简单说明Actor与线程的问题.Actor并非与线程一一对应, 一个线程可以为多个Actor服务. ActorSystem会根据实际情况选择线程数.