Scala Actor

最新推荐文章于 2023-08-31 13:49:18 发布
最新推荐文章于 2023-08-31 13:49:18 发布
阅读量878 收藏
点赞数
分类专栏： scala 文章标签： scala

Scala Actor

  1. 课程目标
    1. 目标一：熟悉Scala Actor并发编程
    2. 目标二：为学习Akka做准备

注：我们现在学的Scala Actor是scala 2.10.x版本及以前版本的Actor。

Scala在2.11.x版本中将Akka加入其中，作为其默认的Actor，老版本的Actor已经废弃

  1. 什么是Scala Actor
    1. 概念

Scala中的Actor能够实现并行编程的强大功能，它是基于事件模型的并发机制，Scala是运用消息（message）的发送、接收来实现多线程的。使用Scala能够更容易地实现多线程应用的开发。

    1. 传统java并发编程与Scala Actor编程的区别

 

对于Java，我们都知道它的多线程实现需要对共享资源（变量、对象等）

使用synchronized 关键字进行代码块同步、对象锁互斥等等。

而且，常常一大块的try…catch语句块中加上wait方法、notify方法、notifyAll方法是让人很头疼的。

原因就在于Java中多数使用的是可变状态的对象资源，对这些资源进行共享来实现多线程编程的话，控制好资源竞争与防止对象状态被意外修改是非常重要的，而对象状态的不变性也是较难以保证的。

而在Scala中，我们可以通过复制不可变状态的资源（即对象，Scala中一切都是对象，连函数、方法也是）的一个副本，再基于Actor的消息发送、接收机制进行并行编程

    1. Actor方法执行顺序
  2. 首先调用start()方法启动Actor
  3. 调用start()方法后其act()方法会被执行
  4. 向Actor发送消息
    1. 发送消息的方式

!

发送异步消息，没有返回值。

!?

发送同步消息，等待返回值。

!!

发送异步消息，返回值是 Future[Any]。

 

  1. Actor实战
    1. 第一个例子 
      //注意导包是scala.actors.Actor
import scala.actors.Actor

object MyActor1 extends Actor{

  //重新act方法

  def act(){

    for(i <- 1 to 10){

      println("actor-1 " + i)

      Thread.sleep(2000)

    }

  }

}

  

  object MyActor2 extends Actor{

  //重新act方法

  def act(){

    for(i <- 1 to 10){

      println("actor-2 " + i)

      Thread.sleep(2000)

    }

  }

}

  

  object ActorTest extends App{

  //启动Actor

  MyActor1.start()

  MyActor2.start()

}

       


说明：上面分别调用了两个单例对象的start()方法，他们的act()方法会被执行，相同与在java中开启了两个线程，线程的run()方法会被执行

注意：这两个Actor是并行执行的，act()方法中的for循环执行完成后actor程序就退出了

 

2.第二个例子（可以不断地接收消息）

import scala.actors.Actor

/**
  * Created by ZX on 2016/4/4.
  */
class MyActor extends Actor {

  override def act(): Unit = {
    while (true) {
      receive {
        case "start" => {
          println("starting ...")
          Thread.sleep(5000)
          println("started")
        }
        case "stop" => {
          println("stopping ...")
          Thread.sleep(5000)
          println("stopped ...")
        }
      }
    }
  }
}

object MyActor {
  def main(args: Array[String]) {
    val actor = new MyActor
    actor.start()
    actor ! "start"
    actor ! "stop"
    println("消息发送完成！")
  }
}


注意：发送start消息和stop的消息是异步的，但是Actor接收到消息执行的过程是同步的按顺序执行说明：在act()方法中加入了while (true) 循环，就可以不停的接收消息

 

 

3.第三个例子（react方式会复用线程，比receive更高效）

import scala.actors.Actor

/**
  * Created by ZX on 2016/4/4.
  */
class YourActor extends Actor {

  override def act(): Unit = {
    loop {
      react {
        case "start" => {
          println("starting ...")
          Thread.sleep(5000)
          println("started")
        }
        case "stop" => {
          println("stopping ...")
          Thread.sleep(8000)
          println("stopped ...")
        }
      }
    }
  }
}


object YourActor {
  def main(args: Array[String]) {
    val actor = new YourActor
    actor.start()
    actor ! "start"
    actor ! "stop"
    println("消息发送完成！")
  }
}


说明： react 如果要反复执行消息处理，react外层要用loop，不能用while

 

 

4.第四个例子（结合case class发送消息）

import scala.actors.Actor

class AppleActor extends Actor {

  def act(): Unit = {
    while (true) {
      receive {
        case "start" => println("starting ...")
        case SyncMsg(id, msg) => {
          println(id + ",sync " + msg)
          Thread.sleep(5000)
          sender ! ReplyMsg(3,"finished")
        }
        case AsyncMsg(id, msg) => {
          println(id + ",async " + msg)
          Thread.sleep(5000)
        }
      }
    }
  }
}

object AppleActor {
  def main(args: Array[String]) {
    val a = new AppleActor
    a.start()
    //异步消息
    a ! AsyncMsg(1, "hello actor")
    println("异步消息发送完成")
    //同步消息
    //val content = a.!?(1000, SyncMsg(2, "hello actor"))
    //println(content)
    val reply = a !! SyncMsg(2, "hello actor")
    println(reply.isSet)
    //println("123")
    val c = reply.apply()
    println(reply.isSet)
    println(c)
  }
}
case class SyncMsg(id : Int, msg: String)
case class AsyncMsg(id : Int, msg: String)
case class ReplyMsg(id : Int, msg: String)


练习

用actor并发编程写一个单机版的WorldCount，将多个文件作为输入，计算完成后将多个任务汇总，得到最终的结果

import java.io.File

import scala.actors.{Actor, Future}
import scala.collection.mutable
import scala.io.Source

/**
  * Created by ZX on 2016/4/4.
  */
class Task extends Actor {

  override def act(): Unit = {
    loop {
      react {
        case SubmitTask(fileName) => {
          val contents = Source.fromFile(new File(fileName)).mkString
          val arr = contents.split("\r\n")
          val result = arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.length)
          //val result = arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_ + _._2))
          sender ! ResultTask(result)
        }
        case StopTask => {
          exit()
        }
      }
    }
  }
}

object WorkCount {
  def main(args: Array[String]) {
    val files = Array("c://words.txt", "c://words.log")

    val replaySet = new mutable.HashSet[Future[Any]]
    val resultList = new mutable.ListBuffer[ResultTask]

    for(f <- files) {
      val t = new Task
      val replay = t.start() !! SubmitTask(f)
      replaySet += replay
    }

    while(replaySet.size > 0){
      val toCumpute = replaySet.filter(_.isSet)
      for(r <- toCumpute){
        val result = r.apply()
        resultList += result.asInstanceOf[ResultTask]
        replaySet.remove(r)
      }
      Thread.sleep(100)
    }
    val finalResult = resultList.map(_.result).flatten.groupBy(_._1).mapValues(x => x.foldLeft(0)(_ + _._2))
    println(finalResult)
  }
}

case class SubmitTask(fileName: String)
case object StopTask
case class ResultTask(result: Map[String, Int])

 

 

Scala>Actor介绍
qq_44509920的博客
04-06 386
文章目录Actor介绍Java并发编程的问题Actor并发编程模型Java并发编程对比Actor并发编程创建ActorActor程序运行流程发送消息/接收消息持续接收消息使用loop和react优化接收消息发送和接收自定义消息 Actor介绍 scala的Actor并发编程模型可以用来开发比Java线程效率更高的并发程序。我们学习scala Actor的目的主要是为后续学习Akka做准备。 Jav...
Scala学习笔记7 （actor）
热门推荐
03-04 1万+
7.   actor http://www.scala-lang.org/docu/files/actors-api/actors_api_guide.html#   Scala中处理并发，有很多选择： l  actor消息模型，类似Erlang，首选，Lift和akka也实现了自己的actor模型。 l  Thread、Runnable l  java.uti
Scala中的Actor
象在舞的技术专栏
09-03 578
Scala的Actor类似于Java中的多线程编程。但是不同的是，Scala的Actor提供的模型与多线程有所不同。Scala的Actor尽可能地避免锁和共享状态，从而避免多线程并发时出现资源争用的情况，进而提升多线程编程的性能。此外，Scala Actor的这种模型还可以避免死锁等一系列传统多线程编程的问题。 Scala提供了Actor trait来让我们更方便地进行actor多线程编程，就A
Scala Actor简述
liyifan687的博客
04-28 346
概念 Scala中的Actor能够实现并行编程的强大功能，它是基于事件模型的并发机制，Scala是运用消息（message）的发送、接收来实现多线程的。使用Scala能够更容易地实现多线程应用的开发。 actor方法执行顺序 1.首先调用start()方法启动Actor 2.调用start()方法后其act()方法会被执行 3.向Actor发送消息 发送消息的方式 ...
利用 Scala actor 实现 MySQL 二进制日志流式传输与处理
资源摘要信息:"Guzzler是一个用于从MySQL数据库主服务器上流式传输二进制日志（binlog）的工具，并利用Scala actor模型对这些日志进行处理。尽管Guzzler已被其他工具取代，但它曾是一个在Scala生态中实现MySQL ...
Scala Actor模型详解：消息传递与并发机制
"Actor模型工作机制说明-网络规划设计...这些内容对于理解和使用Scala编程，以及掌握Actor模型的实现具有重要的基础作用。通过学习这些基础知识，可以更好地理解和实践Actor模型，进而应用于实际的并发和并行计算场景。
Scala Actor模型详解：基于FPGA开发与消息机制
在Scala编程中，Actor模型是一种并发处理机制，尤其适用于大规模并行计算和分布式系统。Actor模型的核心思想是将计算过程抽象为独立的实体——Actor，每个Actor都有自己的状态，并通过异步通信来交换信息。以下是对...
Scala入门第八篇--Scala Actor并发编程
weixin_42229056的博客
10-16 495
本次主要介绍Scala Actor并发编程的基本概念和入门下案例 基本概念 Scala中的Actor能够实现并行编程的强大功能，它是基于事件模型的并发机制，Scala是运用消息的发送、接收来实现高并发的。 Actor可以看作是一个个独立的实体，他们之间是毫无关联的。但是，他们可以通过消息来通信。一个Actor收到其他Actor的信息后，它可以根据需要作出各种相应。消息的类型可以是任意的，消息的内...
scala之actor入门
威少（微笑）
05-08 3216
目录 0、Acotr 1、Actor的创建、启动和消息收发 2、收发case class类型的消息 3、Actor之间互相收发消息 4、同步消息和Future（例子待合适情景验证） 0、Acotr （1）java 和 scala 的关联： Scala的Actor类似于Java中的多线程编程 （2）java 和 scala 的区别： 1>Scala的Actor尽可能地避免...
scala-actors-2.10 jar包
11-22
scala-actors-2.10 jar包，可以解决 scala-actors-2.10以上版本带来的不兼容问题
用Scala写的akka actor简单demo
07-16
用Scala写的akka actor简单demo，已经打包成SBT程序，因为上传大小限制依赖包没上传，用户安装了sbt后只需要执行update命令即可
【图文详细 】Scala——Actor
谦卑t
12-28 1048
3、Scala Actor    3.1、概念  Scala 中的 Actor 能够实现并行编程的强大功能，它是基于事件模型的并发机制，Scala 是运 用消息（message）的发送、接收来实现多线程的。使用 Scala 能够更容易地实现多线程应 用的开发。   一个 Actor 是一个容器，它包含状态，行为，信箱，子 Actor 和监管策略，所有这些包含在 一个 ActorReferenc...
Scala Actor用法
hongchenshijie的博客
02-06 1987
文章目录Actor并发编程模型使用方式代码示例效果截图 乱序输出效果截图 正序输出Actor程序运行流程Actor发送消息/接收消息发送信息接收信息代码示例代码效果 持续打印hello持续接收消息代码示例发送和接收自定义消息代码示例一 使用`!?`来发送同步消息代码示例二 使用`!`发送异步无返回消息效果截图代码示例三 使用`!!`发送异步有返回消息 Actor并发编程模型 Actor并发...
Scala actor
zhaomeng1123的专栏
11-15 312
主目录 Akka Actorimport akka.actor.Actor import akka.actor.ActorSystem import akka.actor.Props //定义一个Actor class HelloActor extends Actor { //如果接收到"hello",返回"您好", 如果接收到其它，返回"您是？" def receive = { ca
scala之Actor
xiaoqie159的博客
12-01 219
使用Actor编程模型需要有以下步骤。 1:导入akka的包。 2.写一个Actor的子类，实现receive方法。 3.创建ActorSystem 4.通过ActorSystem创建Actor的一个实例。 5.调用Actor的实例 ...
Scala中的Actor模型
最新发布
m0_46168848的博客
08-31 932
Scala 中的 Actor 模型是一种并发编程模型，用于处理并发和并行计算。Actor 模型的核心概念是基于消息传递和非共享状态，并通过轻量级的执行单元（称为 Actor）来实现并发和协作。Akka 是一个构建可扩展、高性能和弹性系统的工具包，它提供了强大的 Actor 模型库。，我们创建了一个名为 “MySystem” 的 Actor 系统，并创建了一个名为 “myActor” 的 Actor 实例。2.12版本后，actor彻底从scala中抽离了出来，所以我们在使用前需要引入相应的lib。
scala中的Akka、Actor
sinat_26781639的博客
01-18 351
一、Actor模型 对并发编程模型进行了更高的抽象 异步、非阻塞、高并发的事件驱动模型 轻量级事件处理(1G可容纳百万级别个Actor) Actor可以理解为服务中的各个组件，他可以用来接收信息，处理信息，回复信息。actor之间是通过ActorRef来做信息的收发，每个actor会有个邮箱，actorref会往邮箱发送信息 Actor System负责创建和管理Actor是单例的，而Actor是...
scala的Actor介绍
汉子一枚
02-15 543
Actor介绍 scala的Actor并发编程模型可以用来开发比Java线程效率更高的并发程序。我们学习scala Actor的目的主要是为后续学习Akka做准备。 Java并发编程的问题 在Java并发编程中，每个对象都有一个逻辑监视器（monitor），可以用来控制对象的多线程访问。我们添加sychronized关键字来标记，需要进行同步加锁访问。这样，通过加锁的机制来确保同一时间只有一个线程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值