scala系列--并发01

最近研究了一些scala并发的知识，总结一下。

一.简介

即时响应性是一项决定任何应用程序成败的关键因素。有两种方式来提高即时响应性：1.多线程，并行运行多个任务。2.有策略的计算，惰性运行任务。

二.惰性求值

1.短路控制，scala不会向前看，所以用到lazy。
注意：多个变量绑定，后续调用，顺序不可预知。

2.惰性集合，创建临时视图，调用的时候立即求值。

3.无限流转换有限流

有限序列

无限流-》Stream

三.并行集合

顺序集合

顺序集合上的方法行为：它们为它们的集合中的每个元素顺序地执行它们的操作。

并行集合

，Scala 都拥有其并行版本。例如，ParArray 是Array 对应的并行版本，同样的，ParHashMap、ParHashSet 和ParVector 分别对应于HashMap、HashSet 和Vector。我们可以使用par()和seq()方法来在顺序集合及其并行版本之间进行相互转换。

扫描二维码关注公众号，回复： 6392727 查看本文章

四.Actor

简介：

Acotr模式是一种并发模型与另一种模型共享内存完全相反，Actor模型share nothing。
所有线程（或进程）通过消息传递方式进行合作，这些线程（或进程)称为Actor,共享内存更适合单机多核的并发编程。

特点：

保证互斥访问的活动对象。
一个Actor将只会处理一条消息。Actor模型具有与生俱来的线程安全性。
多个Actor并发地运行，同时处理多条消息。
Actor是异步。
不会阻塞调用者。
不用显示创建一个线程池，显示调度任务。
线程并不和Actor绑定--一个线程池服务于多个Actor。
java创建共享可变变量，并使用同步原语来提供线程安全性。使用JDK 库很难在短时间内做到正确的并发。

注意：

更多依赖无状态Actor,少用有状态Actor。
确保Actor之间传递消息是不可变对象（case,String,Int等）。保证我们不会无意间修改共享状态。
尽量避免使用ask().双向通信不是一个好主意。“发送并忘记”（!）模型好得多。

示例：

统计字符串的次数。

import akka.actor._
import scala.collection.mutable
/**
  * 接收消息
  */
class MessageActor extends Actor{
  val messagesCount: mutable.Map[String, Int] =mutable.Map()
  override def receive: Receive = {
    case Play(role) =>
      val currentCount = messagesCount.getOrElse(role, 0)
      messagesCount.update(role, currentCount + 1)
      println(s"Playing $role")

    case ReportCount(role) =>
      sender ! messagesCount.getOrElse(role,0)

  }
}
case class Play(role: String)
case class ReportCount(role: String)

import akka.actor._
import akka.util.Timeout
import akka.pattern.Patterns
import scala.concurrent.Await
import scala.concurrent.duration._

/**
  * Acotr模式是一种并发模型与另一种模型共享内存完全相反，Actor模型share nothing。
  * 所有线程（或进程）通过消息传递方式进行合作，这些线程（或进程)称为Actor,共享内存更适合单机多核的并发编程。
  */
object  UseActor extends App{
  val system = ActorSystem("sample")
  val depp = system.actorOf(Props[MessageActor])
  val hanks = system.actorOf(Props[MessageActor])
   /**
    *tell属于发了就完，什么都不管的类型。
    *
    */
  depp ! Play("Depp1")
  hanks ! Play("Hanks1")

  depp ! Play("Depp1")
  depp ! Play("Depp2")


  println("Sent roles to play ")
  /**
    * 询问（ask ?）模式，因为发送一条消息并等待响应可能会导致潜在的活锁
    * 消息可能永远不会到达,设置超时时间
    */
  implicit val timeout: Timeout = Timeout(2.seconds)
  val depp1 = Patterns.ask(depp, ReportCount("Depp1"), timeout)
  val depp2 = Patterns.ask(depp, ReportCount("Depp2"), timeout)
  val hanks1 = Patterns.ask(hanks, ReportCount("Hanks1"), timeout)

  val depp1Count = Await.result(depp1, timeout.duration)
  val depp2Count = Await.result(depp2, timeout.duration)
  val hanks1Count = Await.result(hanks1, timeout.duration)

  println(s"Depp played Depp1 $depp1Count time(s)")
  println(s"Depp played Depp2 $depp2Count time(s)")
  println(s"Hanks played Hanks1 $hanks1Count time(s)")

  val terminateFuture = system.terminate()
  Await.ready(terminateFuture, Duration.Inf)
}

结果：

Playing Depp1
Playing Hanks1
Sent roles to play
Playing Depp1
Playing Depp2
Depp played Depp1 2 time(s)
Depp played Depp2 1 time(s)
Hanks played Hanks1 1 time(s)

参考《Scala实用指南》

一.简介

二.惰性求值

三.并行集合

四.Actor

猜你喜欢