Scala入门到精通——第二十六节 Scala并发编程基础

最新推荐文章于 2023-07-10 19:12:40 发布

zhouzhihubeyond

最新推荐文章于 2023-07-10 19:12:40 发布

阅读量1.8w

点赞数

本文链接：https://blog.csdn.net/lovehuangjiaju/article/details/47623177

版权

本文介绍了Scala并发编程的基础，包括Actor模型、react模型和Actor的不同状态。重点讲解了Scala中的Actor如何通过消息传递实现线程安全，避免了Java并发中的线程安全问题和死锁。此外，还探讨了Actor的单次执行、处理多个消息以及spawn方法、同步和异步消息发送等高级用法。

摘要由CSDN通过智能技术生成

作者：摇摆少年梦
视频地址：http://www.xuetuwuyou.com/course/12

本节主要内容

Scala并发编程简介
Scala Actor并发编程模型
react模型
Actor的几种状态
Actor深入使用解析

1. Scala并发编程简介

2003 年，Herb Sutter 在他的文章 “The Free Lunch Is Over” 中揭露了行业中最不可告人的一个小秘密，他明确论证了处理器在速度上的发展已经走到了尽头，并且将由全新的单芯片上的并行 “内核”（虚拟 CPU）所取代。这一发现对编程社区造成了不小的冲击，因为正确创建线程安全的代码，在理论而非实践中，始终会提高高性能开发人员的身价，而让各公司难以聘用他们。看上去，仅有少数人充分理解了 Java 的线程模型、并发 API 以及 “同步” 的含义，以便能够编写同时提供安全性和吞吐量的代码 —— 并且大多数人已经明白了它的困难所在（来源：http://www.ibm.com/developerworks/cn/java/j-scala02049.html）。

在Java中，要编写一个线程安全的程序并不是一件易事，例如：

class Account {  
    private int balance;  

    synchronized public int getBalance() {  
      return balance;  
    }  

    synchronized public void incrementBalance() {  
      balance++;  
    }  
}

上面这段java代码虽然方法前面加了synchronized ，但它仍然不是线程安全的，例如，在执行下面两个语句

account.incrementBalance();  
account.getBalance();

时，有可能account.incrementBalance()执行完成后，其它线程可能会获取对象的锁，修改account的balance，从而造成得不到预期结果的问题。解决问题的方法是将两个功能结合起来形成一个方法：

synchronized public int incrementAndGetBalance() {  
  balance++;  
  return balance;  
}

但这可能并不是我们想要的，每次获取balance都要将balance增加，这显然与实际不符。除此之外，java中的并发编程可能还会经常遇到死锁问题，而这个问题往往难调试，问题可能会随机性的出现。总体上来看，java的并发编程模型相对较复杂，难以驾驭。

Scala很好地解决了java并发编程的问题，要在scala中进行并发编程，有以下几种途径可以实现：
1 actor消息模型、akka actor并发模型。

2 Thread、Runnable

3 java.util.concurennt

4 第三方开源并发框架如Netty，Mina

在上述四种途径当中，利用 actor消息模型、akka actor并发模型是scala并发编程的首先，本节主要介绍actor消息模型，akka actor并发模型我们将放在后面的章节中介绍。
在scala中，通过不变对象来实现线程安全，涉及到修改对象状态时，则创建一个新的对象来实现，如：

//成员balance状态一旦被赋值，便不能更改
//因而它也是线程安全的
class Person(val age: Integer) {
     
  def getAge() = age
}  

object Person{
     
  //创建新的对象来实现对象状态修改
  def increment(person: Person): Person{  
    new Person(Person.getAge() + 1)  
  }  
}

通过不变对象实现并发编程，可以简化编程模型，使并发程序更容易现实和控制。

2.Scala Actor并发编程模型

java中的并发主要是通过线程来实现，各线程采用共享资源的机制来实现程序的并发，这里面临竞争资源的问题，虽然采用锁机制可以避免竞争资源的问题，但会存在死锁问题，要开发一套健壮的并发应用程序具有一定的难度。而scala的并发模型相比于java它更简单，它采用消息传递而非资源共享来实现程序的并发，消息传递正是通过Actor来实现的。下面的代码给出了Actor使用示例

//混入Actor特质，然后实现act方法
//如同java中的Runnable接口一样
//各线程的run方法是并发执行的
//Actor中的act方法也是并发执行的
class ActorDemo extends Actor{
   
  //实现 act()方法
  def act(){
    while(true){
      //receive从邮箱中获取一条消息
      //然后传递给它的参数
      //该参数是一个偏函数
      receive{
        case "actorDemo" => println("receive....ActorDemo")
      }      
    }
  }
}
object ActorDemo extends App{
   
  val actor=new ActorDemo
  //启动创建的actor 
  actor.start()
  //主线程发送消息给actor
  actor!"actorDemo"
}

下面给的是recieve方法的部分源代码

def receive[R](f: PartialFunction[Any, R]): R = {
    assert(Actor.self(scheduler) == this, "receive from channel belonging to other actor")

    synchronized {
      if (shouldExit) exit() // links
      drainSendBuffer(mailbox)
    }

    var done = false
    while (!done) {
      val qel = mailbox.extractFirst((m: Any, replyTo: OutputChannel[Any]) => {
        senders = replyTo :: senders
        val matches = f.isDefinedAt(m)
        senders = senders.tail
        matches
      })
................

从上述代码中不能看出，receive方法接受的参数是一个偏函数，并且是通过mailbox来实现消息的发送与接收。

在前述的class ActorDemo中，receive方法的参数为