Akka模拟实现Spark中Master Worker 进程通讯

最新推荐文章于 2021-01-22 12:44:18 发布
最新推荐文章于 2021-01-22 12:44:18 发布
阅读量355 收藏
点赞数
分类专栏： Scala 文章标签： Akka Spark Scala Master Worker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sltylzx/article/details/89742720
版权

0.引入akka依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.w4xj.scala</groupId>
    <artifactId>akka</artifactId>
    <version>1.0-SNAPSHOT</version>


    <!-- 定义一下常量 -->
    <properties>
        <encoding>UTF-8</encoding>
        <scala.version>2.11.8</scala.version>
        <scala.compat.version>2.11</scala.compat.version>
        <akka.version>2.4.17</akka.version>
    </properties>

    <dependencies>
        <!-- 添加scala的依赖 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>

        <!-- 添加akka的actor依赖 -->
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor_${scala.compat.version}</artifactId>
            <version>${akka.version}</version>
        </dependency>

        <!-- 多进程之间的Actor通信 -->
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-remote_${scala.compat.version}</artifactId>
            <version>${akka.version}</version>
        </dependency>
    </dependencies>

    <!-- 指定插件-->
    <build>
        <!-- 指定源码包和测试包的位置 -->
        <sourceDirectory>src/main/scala</sourceDirectory>
        <testSourceDirectory>src/test/scala</testSourceDirectory>
        <plugins>
            <!-- 指定编译scala的插件 -->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                        <configuration>
                            <args>
                                <arg>-dependencyfile</arg>
                                <arg>${project.build.directory}/.scala_dependencies</arg>
                            </args>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- maven打包的插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>reference.conf</resource>
                                </transformer>
                                <!-- 指定main方法 -->
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>xxx</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>


</project>

1.Spark Master Worker 进程通讯案例（注册）

[1].需求分析

①.worker注册到Master, Master完成注册，并回复worker注册成功

②.worker定时发送心跳，并在Master接收到

③.Master接收到worker心跳后，要更新该worker的最近一次发送心跳的时间

④.给Master启动定时任务，定时检测注册的worker有哪些没有更新心跳,并将其从hashmap中删除

⑤.master worker 进行分布式部署(Linux系统)-》如何给maven项目打包->上传linux

[2].代码

①.传输协议（序列化类、实体类）

package com.w4xj.scala.sparkregister


/**

  * worker注册信息

  */

case class RegisterWorkerInfo(id: String, cpu: Int, ram: Int)


/**

  * 这个是WorkerInfo, 保存在master的hashmap中的

   * @param id

  * @param cpu

  * @param ram

  */

class WorkerInfo(val id: String, val cpu: Int, val ram: Int)


/**

  * 返回注册成功信息

  */

case object RegisteredWorkerInfo

②.Master

package com.w4xj.scala.sparkregister


import akka.actor.{Actor, ActorSystem, Props}

import com.typesafe.config.ConfigFactory


class SparkMaster extends Actor { //SparkMaster.scala

  val workers = collection.mutable.HashMap[String, WorkerInfo]()


  override def receive: Receive = {

    case "start" => println("master服务，启动并开始监听端口....")



    case RegisterWorkerInfo(workerId, cpu, ram) => {

      if (!workers.contains(workerId)) {

        println(workerId + " 注册ok.... ")

        val workerInfo = new WorkerInfo(workerId, cpu, ram)

        workers += ((workerId, workerInfo))

        sender() ! RegisteredWorkerInfo

      }

    }

  }

}


object SparkMaster {

  def main(args: Array[String]): Unit = {

    val config = ConfigFactory.parseString(

      s"""

         |akka.actor.provider="akka.remote.RemoteActorRefProvider"

         |akka.remote.netty.tcp.hostname=127.0.0.1

         |akka.remote.netty.tcp.port=10001

            """.stripMargin)

    val actorSystem = ActorSystem("sparkMaster", config)

    val masterActorRef = actorSystem.actorOf(Props[SparkMaster], "master-01")

    masterActorRef ! "start"

  }

}

③.Worker

package com.w4xj.scala.sparkregister



import java.util.UUID



import akka.actor.{Actor, ActorSelection, ActorSystem, Props}

import com.typesafe.config.ConfigFactory



class SparkWorker(masterUrl: String) extends Actor {

  var masterProxy: ActorSelection = _

  val workerId = UUID.randomUUID().toString



  override def preStart(): Unit = {

    masterProxy = context.actorSelection(masterUrl)

  }



  override def receive: Receive = {

    case "start" => { // 自己已就绪

      println(workerId + " 向master发出注册信息... ")

      masterProxy ! RegisterWorkerInfo(workerId, 1, 64 * 1024) //

    }

    case RegisteredWorkerInfo => {

      println(workerId + " 向master注册成功了... ")

    }

  }

}



object SparkWorker {

  def main(args: Array[String]): Unit = {

    val host = "127.0.0.1"

    val port = 10002

    val masterURL = "akka.tcp://sparkMaster@127.0.0.1:10001/user/master-01"

    val workerName = "worker-01"

    val config = ConfigFactory.parseString(

      s"""

         |akka.actor.provider="akka.remote.RemoteActorRefProvider"

         |akka.remote.netty.tcp.hostname=127.0.0.1

         |akka.remote.netty.tcp.port=10002

            """.stripMargin)

    val actorSystem = ActorSystem("sparkWorker", config)

    val workerActorRef = actorSystem.actorOf(Props(new SparkWorker(masterURL)), workerName)

    workerActorRef ! "start"

  }

}

[3].运行

①.先启动Master

②.再启动Worker注册到Master

3cf12045-bdc6-4ee7-be21-fe8f50fd7c89 向master发出注册信息...

[WARN] [SECURITY][05/01/2019 18:48:35.656] [sparkWorker-akka.remote.default-remote-dispatcher-6] [akka.serialization.Serialization(akka://sparkWorker)] Using the default Java serializer for class [com.w4xj.scala.sparkregister.RegisterWorkerInfo] which is not recommended because of performance implications. Use another serializer or disable this warning using the setting 'akka.actor.warn-about-java-serializer-usage'

3cf12045-bdc6-4ee7-be21-fe8f50fd7c89 向master注册成功了...

11.Spark Master Worker 进程通讯案例（worker定时发送心跳）

[1].需求分析

①.worker注册成功后启动定时器，向master定时发送心跳

②.master接收到worker的心跳，更新worker的最新心跳时间

[2].实现

①.新增协议（样例类）

/**

  * 发送心跳的指令

  */

case object SendHeartBeat


/**

  * 心跳协议

  * @param id

  */

case class HearBeat(id: String)

②.修改WorkerInfo

class WorkerInfo(val id: String, val cpu: Int, val ram: Int){

// 新增最新心跳时间

var lastHeartBeatTime: Long = _

}

③.worker注册完成后启动定时器

case RegisteredWorkerInfo => {

  println(workerId + " 向master注册成功了... ")

  println(workerId + " 准备开始定时发送心跳消息给master... ")

  //启动定时器向自己发送【发送心跳的指令】

  import context.dispatcher

  //0 millis：无延时立即启动

  //3000 millis：每3秒执行一次定时器

  //self：向自己发送

  //SendHeartBeat：发送心跳的指令

  context.system.scheduler.schedule(0 millis, 3000 millis, self, SendHeartBeat)

}

④.向master发送心跳

//向master发送心跳

case SendHeartBeat => {

  // 向master发送心跳了

  println(s"------- $workerId 发送心跳-------")

  masterProxy ! HearBeat(workerId)

}

⑤.master接收到心跳，更新最新心跳时间

//worker向服务端发送心跳

case HearBeat(workerId) => {

  val workerInfo = workers(workerId)

  workerInfo.lastHeartBeatTime = System.currentTimeMillis()

  println(s"master：${workerId} 更新了心跳时间...")

}

[3].运行效果

①.worker

7cceb8c1-9543-47f3-b171-8a73f2620d79 准备开始定时发送心跳消息给master...

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

[WARN] [SECURITY][05/02/2019 08:05:45.367] [sparkWorker-akka.remote.default-remote-dispatcher-9] [akka.serialization.Serialization(akka://sparkWorker)] Using the default Java serializer for class [com.w4xj.scala.sparkregister.HearBeat] which is not recommended because of performance implications. Use another serializer or disable this warning using the setting 'akka.actor.warn-about-java-serializer-usage'

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

------- 7cceb8c1-9543-47f3-b171-8a73f2620d79 发送心跳-------

②.master

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

master：7cceb8c1-9543-47f3-b171-8a73f2620d79 更新了心跳时间...

2.Spark Master Worker 进程通讯案例（Master定时检测worker的存活）

[1].需求：Master启动定时任务，定时检测注册的worker有哪些没有更新心跳，已经超时的worker，将其从hashmap中删除掉

[2].实现

①.新增2个协议

/**

  * master给自己发送一个触发检查超时worker的信息

  */

case object StartTimeOutWorker



/**

  * master给自己发消息，检测worker，移除超时的worker

  */

case object RemoveTimeOutWorker

②.启动master的同时开启定时调度（直接或间接）

case "start" => {

  println("master服务，启动并开始监听端口....")


  //发送启动调度器消息，其实这里可直接启动调度器，spark这里是单独发送了一个消息触发定时器

  self ! StartTimeOutWorker

}


// 开启定时器，每隔一定时间检测是否有worker的心跳超时

case StartTimeOutWorker => {

  // 使用调度器时候必须导入dispatcher

  import context.dispatcher

  context.system.scheduler.schedule(0 millis, 9000 millis, self, RemoveTimeOutWorker)

}

③.检测超时的worker，并移除

case RemoveTimeOutWorker => {

  val workerInfos = workers.values

  val currentTime = System.currentTimeMillis()

  // 过滤出心跳超时的worker，然后移除掉

  workerInfos

    .filter(workerInfo => currentTime - workerInfo.lastHeartBeatTime > 6000)

    .foreach(workerInfo => workers.remove(workerInfo.id))

  println(s"-----还剩 ${workers.size} 存活的Worker-----")

}

[3].运行效果

master服务，启动并开始监听端口....

-----还剩 0 存活的Worker-----

-----还剩 0 存活的Worker-----

0b557f37-d2e5-4018-9884-16851f7dfe25 注册ok....

[WARN] [SECURITY][05/02/2019 08:38:08.846] [sparkMaster-akka.remote.default-remote-dispatcher-8] [akka.serialization.Serialization(akka://sparkMaster)] Using the default Java serializer for class [com.w4xj.scala.sparkregister.RegisteredWorkerInfo$] which is not recommended because of performance implications. Use another serializer or disable this warning using the setting 'akka.actor.warn-about-java-serializer-usage'

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

-----还剩 1 存活的Worker-----

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

-----还剩 1 存活的Worker-----

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

master：0b557f37-d2e5-4018-9884-16851f7dfe25 更新了心跳时间...

[WARN] [05/02/2019 08:38:33.503] [sparkMaster-akka.remote.default-remote-dispatcher-9] [akka.tcp://sparkMaster@127.0.0.1:10001/system/endpointManager/reliableEndpointWriter-akka.tcp%3A%2F%2FsparkWorker%40127.0.0.1%3A10002-0] Association with remote system [akka.tcp://sparkWorker@127.0.0.1:10002] has failed, address is now gated for [5000] ms. Reason: [Disassociated]

-----还剩 1 存活的Worker-----

-----还剩 0 存活的Worker-----

3.Spark Master Worker 进程通讯案例（提取运行参数）

[1].修改后的Master

package com.w4xj.scala.sparkregister


import akka.actor.{Actor, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import scala.concurrent.duration._



class SparkMaster extends Actor { //SparkMaster.scala
  val workers = collection.mutable.HashMap[String, WorkerInfo]()


  override def receive: Receive = {
    case "start" => {
      println("master服务，启动并开始监听端口....")
      //发送启动调度器消息，其实这里可直接启动调度器，spark这里是单独发送了一个消息触发定时器
      self ! StartTimeOutWorker
    }



    //worker向服务端发送注册信息

    case RegisterWorkerInfo(workerId, cpu, ram) => {
      if (!workers.contains(workerId)) {
        println(workerId + " 注册ok.... ")
        val workerInfo = new WorkerInfo(workerId, cpu, ram)
        workers += ((workerId, workerInfo))
        sender() ! RegisteredWorkerInfo
      }
    }

    //worker向服务端发送心跳
    case HearBeat(workerId) => {
      val workerInfo = workers(workerId)
      workerInfo.lastHeartBeatTime = System.currentTimeMillis()
      println(s"master：${workerId} 更新了心跳时间...")
    }

    // 开启定时器，每隔一定时间检测是否有worker的心跳超时

    case StartTimeOutWorker => {
      // 使用调度器时候必须导入dispatcher
      import context.dispatcher
      context.system.scheduler.schedule(0 millis, 9000 millis, self, RemoveTimeOutWorker)
    }

    case RemoveTimeOutWorker => {
      val workerInfos = workers.values
      val currentTime = System.currentTimeMillis()
      // 过滤出心跳超时的worker，然后移除掉
      workerInfos
        .filter(workerInfo => currentTime - workerInfo.lastHeartBeatTime > 6000)
        .foreach(workerInfo => workers.remove(workerInfo.id))
      println(s"-----还剩 ${workers.size} 存活的Worker-----")
    }

  }

}


object SparkMaster {
  def main(args: Array[String]): Unit = {
    if(args.length != 3) {
      println("请输入参数：masterHost MasterPort masterName")
      sys.exit() // 退出程序
    }

    val masterHost = args(0)
    val MasterPort = args(1)
    val masterName = args(2)
    val config = ConfigFactory.parseString(
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname=${masterHost}
         |akka.remote.netty.tcp.port=${MasterPort}
            """.stripMargin)
    val actorSystem = ActorSystem("sparkMaster", config)
    val masterActorRef = actorSystem.actorOf(Props[SparkMaster], masterName)
    masterActorRef ! "start"

  }
}

[2].修改后的Worker

package com.w4xj.scala.sparkregister

import java.util.UUID
import scala.concurrent.duration._
import akka.actor.{Actor, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory


class SparkWorker(masterHost: String, masterPort: String, masterName: String) extends Actor {
  var masterProxy: ActorSelection = _
  val workerId = UUID.randomUUID().toString

  override def preStart(): Unit = {
    masterProxy = context.actorSelection(s"akka.tcp://sparkMaster@${masterHost}:${masterPort}/user/${masterName}")

  }

  override def receive: Receive = {
    case "start" => { // 自己已就绪
      println(workerId + " 向master发出注册信息... ")
      masterProxy ! RegisterWorkerInfo(workerId, 1, 64 * 1024) //
    }

    case RegisteredWorkerInfo => {
      println(workerId + " 向master注册成功了... ")
      println(workerId + " 准备开始定时发送心跳消息给master... ")
      //启动定时器向自己发送【发送心跳的指令】
      import context.dispatcher
      //0 millis：无延时立即启动
      //3000 millis：每3秒执行一次定时器
      //self：向自己发送
      //SendHeartBeat：发送心跳的指令
      context.system.scheduler.schedule(0 millis, 3000 millis, self, SendHeartBeat)

    }

    //向master发送心跳
    case SendHeartBeat => {
      // 向master发送心跳了
      println(s"------- $workerId 发送心跳-------")
      masterProxy ! HearBeat(workerId)

    }

  }

}


object SparkWorker {
  def main(args: Array[String]): Unit = {
    if (args.length != 6) {
      println("请输入参数：workerHost workerPort workerName masterHost masterPort masterName")
      sys.exit() // 退出程序

    }

    val workerHost = args(0)
    val workerPort = args(1)
    val workerName = args(2)
    val masterHost = args(3)
    val masterPort = args(4)
    val masterName = args(5)
    val config = ConfigFactory.parseString(
      s"""
         |akka.actor.provider="akka.remote.RemoteActorRefProvider"
         |akka.remote.netty.tcp.hostname=${workerHost}
         |akka.remote.netty.tcp.port=${workerPort}
            """.stripMargin)

    val actorSystem = ActorSystem("sparkWorker", config)
    val workerActorRef = actorSystem.actorOf(Props(new SparkWorker(masterHost, masterPort, masterName)), workerName)
    workerActorRef ! "start"
  }

}

[3].测试

①.先启动Master

127.0.0.1
9999
masterName

②.启动worker1

127.0.0.1
9001
workerName1
127.0.0.1
9999
masterName

③.启动worker2

127.0.0.1
9002
workerName2
127.0.0.1
9999
masterName

④.启动worker3

127.0.0.1
9003
workerName3
127.0.0.1
9999
masterName

⑤.依次关闭worker

⑥.运行结果

master服务，启动并开始监听端口....

-----还剩 0 存活的Worker-----

-----还剩 0 存活的Worker-----

-----还剩 0 存活的Worker-----

-----还剩 0 存活的Worker-----

a8bd90e6-f756-45a2-9c3b-b43523025e22 注册ok....

[WARN] [SECURITY][05/02/2019 09:16:51.527] [sparkMaster-akka.remote.default-remote-dispatcher-9] [akka.serialization.Serialization(akka://sparkMaster)] Using the default Java serializer for class [com.w4xj.scala.sparkregister.RegisteredWorkerInfo$] which is not recommended because of performance implications. Use another serializer or disable this warning using the setting 'akka.actor.warn-about-java-serializer-usage'

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

-----还剩 1 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

35ab4ef6-06ac-4fc5-b39d-c62a90c97004 注册ok....

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 2 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 2 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 2 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

b2baf4ca-0717-4d29-824a-2ab1027465b8 注册ok....

master：b2baf4ca-0717-4d29-824a-2ab1027465b8 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：b2baf4ca-0717-4d29-824a-2ab1027465b8 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 3 存活的Worker-----

master：b2baf4ca-0717-4d29-824a-2ab1027465b8 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：b2baf4ca-0717-4d29-824a-2ab1027465b8 更新了心跳时间...

[WARN] [05/02/2019 09:17:47.189] [sparkMaster-akka.remote.default-remote-dispatcher-10] [akka.tcp://sparkMaster@127.0.0.1:9999/system/endpointManager/reliableEndpointWriter-akka.tcp%3A%2F%2FsparkWorker%40127.0.0.1%3A9003-2] Association with remote system [akka.tcp://sparkWorker@127.0.0.1:9003] has failed, address is now gated for [5000] ms. Reason: [Disassociated]

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 3 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

-----还剩 2 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：35ab4ef6-06ac-4fc5-b39d-c62a90c97004 更新了心跳时间...

[WARN] [05/02/2019 09:18:04.505] [sparkMaster-akka.remote.default-remote-dispatcher-10] [akka.tcp://sparkMaster@127.0.0.1:9999/system/endpointManager/reliableEndpointWriter-akka.tcp%3A%2F%2FsparkWorker%40127.0.0.1%3A9002-1] Association with remote system [akka.tcp://sparkWorker@127.0.0.1:9002] has failed, address is now gated for [5000] ms. Reason: [Disassociated]

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

-----还剩 1 存活的Worker-----

master：a8bd90e6-f756-45a2-9c3b-b43523025e22 更新了心跳时间...

[WARN] [05/02/2019 09:18:13.081] [sparkMaster-akka.remote.default-remote-dispatcher-10] [akka.tcp://sparkMaster@127.0.0.1:9999/system/endpointManager/reliableEndpointWriter-akka.tcp%3A%2F%2FsparkWorker%40127.0.0.1%3A9001-0] Association with remote system [akka.tcp://sparkWorker@127.0.0.1:9001] has failed, address is now gated for [5000] ms. Reason: [Disassociated]

-----还剩 0 存活的Worker-----

 

 

w4xj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Akka反模式：Java序列化
06-16 375
当消息离开JVM边界时， Akka将使用序列化。 这可能主要发生在两种情况下：使用Akka Cluster（ 不要直接使用Akka Remote ）或使用Akka Persistence通过网络发送消息时。 现在有个问题：在Akka中配置的默认序列化技术不过是臭名昭著的Java序列化， Mark Reinhold称之为“可怕的错误”，并且Oracle计划在不久的将来将其转储 。 使用J...
Akka in JAVA(三)
weixin_34130269的博客
01-24 232
2019独角兽企业重金招聘Python工程师标准>>> ...
scala中的Akka、Actor
sinat_26781639的博客
01-18 310
一、Actor模型 对并发编程模型进行了更高的抽象 异步、非阻塞、高并发的事件驱动模型 轻量级事件处理(1G可容纳百万级别个Actor) Actor可以理解为服务中的各个组件，他可以用来接收信息，处理信息，回复信息。actor之间是通过ActorRef来做信息的收发，每个actor会有个邮箱，actorref会往邮箱发送信息 Actor System负责创建和管理Actor是单例的，而Actor是...
ScalaPB（1）： using protobuf in akka
TIGER_XC的专栏
04-30 422
任何类型的实例作为消息在两端独立系统的机器之间进行传递时必须经过序列化/反序列化serialize/deserialize处理过程。假设以下场景：在一个网络里有两台连接的服务器，它们分别部署了独立的akka系统。如果我们需要在这两台服务器的akka系统之间进行消息交换的话，所有消息都必须经过序列化/反序列化处理。akka系统对于用户自定义消息类型的默认序列化处理是以java-object seri...
Scala入门六——Akka编写一个RPC框架,模拟多个Worker连接Master
guo20082200的博客
09-17 516
1. Master package com.ghq.rpc import akka.actor.{Actor, ActorRef, ActorSystem, PoisonPill, Props} import language.postfixOps import com.typesafe.config.ConfigFactory import akka.event.Logging impo...
25Akka
01-07
Akka是spark中提供的通信模型。 Akka特点:高可靠.,高性能,高容错,可扩展的分布式RPC功能 所有的通信模型都是基于Actor。 spark里的角色有两个:master和worker，集群先启动master，然后再启动worker， worker需要向...
Spark Core介绍
02-16
Standalone模式下，系统有Master和Worker节点，Master负责资源分配，Worker执行任务。在YARN或Mesos上，Spark作为应用运行在这些资源管理器之上，通过YarnAllocator或MesosClusterDispatcher协调资源。 数据源是...
【Spark内核篇01】Spark通信架构和集群启动流程1
08-04
1. RpcEndpoint：每个节点（如Client、Master、Worker）都是一个独立的RPC端点，实现特定的消息处理逻辑。 2. RpcEnv：RPC环境，为每个端点提供运行时支持。 3. Dispatcher：负责消息的分发，将消息路由到正确的收件...
Spark源码分析3-The connect between driver,master and excutor
08-05
在Spark的分布式计算框架中，驱动器(Driver)、主节点(Master)和执行器(Executor)是核心组件，它们之间的通信和协作构成了Spark作业执行的基础。本文将深入探讨这三个组件的职责、交互方式以及源码背后的实现原理。 ...
study-spark:spark原始码学习，基于spark原始码中涉及的技术总结，rpc，设计模式，线程池等
03-23
2. 单例模式：在Spark中，例如Master节点和Driver节点通常采用单例模式，确保在整个程序运行过程中只有一个实例存在，保证了全局状态的一致性。 3. 模板方法模式：Spark的Transformation和Action操作遵循模板方法...
java akka_Akka反模式：Java序列化
07-09 396
java akka 当消息离开JVM边界时， Akka将使用序列化。 这可能主要发生在两种情况下：使用Akka Cluster（ 不要直接使用Akka Remote ）或使用Akka Persistence通过网络发送消息时。 现在有个问题：在Akka中配置的默认序列化技术不过是臭名昭著的Java序列化， Mark Reinhold称之为“可怕的错误”，并且Oracle计划在不久的将来将其转...
基于Akka模拟Spark中Master和Worker的通信过程
zp的博客
06-08 917
一、Spark中Master与Worker之间的通信过程 1、在启动时，Worker会向Master注册自己的信息(内存、核数等)，以便 2、Master收到各Worker的注册信息后，会回复Worker已注册成功的信息 3、worker收到master的注册成功信息后，会定期向Master发送心跳包，回报自己的状态信息 4、Master定期收到Worker的心跳信息后，会更新各个Wo...
spark中master和worker之间的进程通讯（心跳机制）
liyang7916的博客
01-22 981
模拟spark源码的心跳机制 worker注册到Master, Master完成注册，并回复worker注册成功 worker定时发送心跳 Master接收到worker心跳后，要更新该worker的最近一次发送心跳的时间 给Master启动定时任务，定时检测注册的worker有哪些没有更新心跳,并将其从hashmap中删除 这个项目总体分三部分（三个模块） worker向master完成注册 worker定时向master发送心跳信息 master启动定时任务，定时监测worker.
Spark中master与worker的进程通信实现
自由幻想的博客
01-27 2511
1.构建master的actor package SparkRPC import akka.actor.{Actor, ActorSystem, Props} import com.typesafe.config.ConfigFactory import scala.collection.mutable /** * Created by hqs on 2018/1/24. * 1.
Akka 通信框架在java端项目的安装,环境的准备,简介和入门程序(1)
桂林算啦粉的博客
09-15 605
一 Akka简介 1 akka的定义 Akka是JAVA虚拟机平台上构建高并发、分布式和容错应用的工具包, 是异步、非阻塞、高性能的事件驱动编程模型 /通信框架。Akka用Scala语言编写，同时提供了Scala和Java的开发接口。Akka处理并发的方法基于Actor模型，Actor之间通信的唯一机制就是消息传递。 在Akka中执行单元是Actor ,在Actor模型中并不是通过Actor对象的某个方法来告诉Actor需要做什么，而是给Actor发送一条消息。当一个Actor收到消息后，它...
分布式应用框架Akka快速入门
xidajiancun
12-11 1299
转载请注明出处：http://blog.csdn.net/jmppok/article/details/17264495 本文结合网上一些资料，对他们进行整理，摘选和翻译而成，对Akka进行简要的说明。引用资料在最后列出。 1.什么是Akka Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。 官方网站 （htt...
RedisTemplate SerializationFailedException: Failed to deserialize payload 异常解决
热门推荐
huilixiang的专栏
02-19 3万+
问题描述：    使用RedisTemplate(spring-data-redis )进行redis操作的封装 ， 现有一个incr的key , 当调用incr后返回值一切正常， 当对此key进行get调用的时候出现了如下的异常：     org.springframework.data.redis.serializer.SerializationException: Cannot dese
spark使用akka干嘛
最新发布
06-12
在Spark中，Akka主要被用来实现分布式任务的调度和执行。具体来说，Spark使用Akka来实现以下几个方面的功能： 1. 任务调度：Spark使用Akka的actor模型来实现任务的调度功能，将任务分配给集群中的不同节点进行处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值