如何进行Spark底层通信RPC源码分析

本篇文章给大家分享的是有关如何进行Spark底层通信RPC源码分析，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。

RPC通信:无论是hadoop2.x的Rpc通信方式还是Spark2.x的Rpc通信方式，简单通俗的来说就是两个进程之间的远程通信，比如java 一个A项目里面有一个class A，里面有一个washA方法一个B项目里面有一个Class B类，里面有一个方法是washB，B项目通过代理模式以及java的反射机制调用到A项目里面的washA,这种情况下就可以理解为是一个简单的Rpc通信方式。

Spark2.x

Spark2.x使用基于RPC的通信方式，去除了1.x的Akka的实现方式，只保留了netty的实现方式，Spark2.x Rpc提供了上层抽象（RpcEndpoint、RpcEnv、RpcEndPointRef），具体的实现方式只要实现了定义的抽象就可以完成Rpc通信，Spark2.x之后目前版本只保留了Netty（NettyRpcEnv、NettyRpcEndpointRef）的实现，定义抽象最大的好处相信开发的朋友都很清楚，以后不管提供了什么方式的实现只要实现了RPCEndpoint,RpcEnv，RpcEndpointRef就可以完成的通信功能。比如自己写一个自己版本的Rpc通信实现。

Spark2.x的Rpc通信方式主要包括一下几个重要方面

RpcEndpoint:消息通信体，主要是用来接收消息、处理消息，实现了RpcEndPoint接口就是一个消息通信体（Master、Work），RpcEndpoint 需要向RpcEnv注册

RpcEnv:Rpc通信的上下文环境，消息发送过来首先经过RpcEnv然后路由给对应的RpcEndPoint，得到RpcEndPoint

RpcEndPointRef:RpcEndPoint的引用如果要想某个RpcEndPoint发送消息，首先要通过RpcEnv得到RpcEndPoint的引用

RpcEndPoint 接口 里面的定义如下

val rpcEnv : RpcEnv //得到RpcEnv对象

final def self: RpcEndpointRef = {//返回一个RpcEnpointRef这个方法通常用来自己给自己发送消息

    rpcEnv.endpointRef(this)

  }

def receive: PartialFunction[Any, Unit]//处理RpcEndPointRef.send 或者RpcEndPointRef.reply方法，该方法不需要进行响应信息

def receiveAndReply(context: RpcCallContext): PartialFunction[Any, Unit]//处理RpcEndPointref.ask发送的消息，处理完之后需要给调用ask的通信端响应消息（reply）

def onError(cause: Throwable)//处理消息失败的时候会调用此方法

def onConnected(remoteAddress: RpcAddress)//远程连接的当前节点的时候触发

def onDisconnected(remoteAddress: RpcAddress)//远程连接断开时候触发

def onNetworkError(cause: Throwable, remoteAddress: RpcAddress)//远程连接发生网络异常时触发

def onStop()//停止RpcEndPoint

def onStart()//启动RpcEndPoint，这里不仅仅是网络上说的启动RpcEndPoint处理任何消息，onStart方法里面很多情况下可以写自己的RpcEndPoint的一些实现比如启动端口，或者创建目录

但是RpcEndPoint只有在onStart方法做一些处理之后 才可以接受RpcEndPointRef发送的消息

private[spark] trait ThreadSafeRpcEndpoint extends RpcEndpoint//因为receive是并发操作如果要现成安全就是用threadSafeRpcEndPoint

RpcEndPoint的生命周期 构造--> onStart--> receive -->onStop,注意onStart的方法是在调用setRpcEndPoint注册之后就会执行任何RpcEndPoint的onStart方法都是在注册之后执行的

原因后面的源码的提到

RpcEndpointRef:抽象类

  def address: RpcAddress //根据主机名端口返回一个RppAddress

def name: String//name 一个字符串 暂时不知道干嘛的

def send(message: Any): Unit//向RpcEndPoint发送一个消息 不需要返回结果

 def ask[T: ClassTag](message: Any, timeout: RpcTimeout): Future[T]

  def ask[T: ClassTag](message: Any): Future[T] = ask(message, defaultAskTimeout) //向RpcEndPoint发送消息并得到返回结果

def askWithRetry[T: ClassTag](message: Any): T = askWithRetry(message, defaultAskTimeout)// 想RpcEndPoint发送消息并在一定时间内返回结果 失败的时候并且进行一定次数的重试

RpcEnv

  private[rpc] def endpointRef(endpoint: RpcEndpoint): RpcEndpointRef//传入RpcEndPoint得到RpcEndPointref对象

  def address: RpcAddress//根据主机名端口返回一个RppAddress

def setupEndpoint(name: String, endpoint: RpcEndpoint): RpcEndpointRef//注册RpcEndPoint返回对应的RpcEndPointRef

def asyncSetupEndpointRefByURI(uri: String): Future[RpcEndpointRef]//通过uri一步获取 RpcEndPointRef

 def stop(endpoint: RpcEndpointRef): Unit//停止RpcEndPoint根据RpcEndPointRef

  def shutdown(): Unit//关闭RpcEndPoint

 def awaitTermination(): Unit//等待RpcEndPoint退出

object RpcEnv

 def create(

      name: String,

      host: String,

      port: Int,

      conf: SparkConf,

      securityManager: SecurityManager,

      clientMode: Boolean = false): RpcEnv = {

    val config = RpcEnvConfig(conf, name, host, port, securityManager, clientMode)

    new NettyRpcEnvFactory().create(config)

  }

//通过RpcEnvFactory.create创建RpcEnv环境

RpcEnvConfig

private[spark] case class RpcEnvConfig(

    conf: SparkConf,

    name: String,

    host: String,

    port: Int,

    securityManager: SecurityManager,

    clientMode: Boolean)

case类 里面包括SparkConf，name,host,port等

NettyRpcEnv NettyRpcEnv通过NettyRpcEnvFactory的create方法创建

 val nettyEnv =

      new NettyRpcEnv(sparkConf, javaSerializerInstance, config.host, config.securityManager)// 创建nettyEnv

 private val dispatcher: Dispatcher = new Dispatcher(this)

Dispatcher负责RPC消息的路由，它能够将消息路由到对应的RpcEndpoint进行处理,同时存放RpcEndPoint与RpcEndPointRef的映射

NettyStreamManager 负责提供文件服务（文件、JAR文件、目录）

TransportContext负责管理网路传输上下文信息：创建MessageEncoder、MessageDecoder、TransportClientFactory、TransportServer

NettyRpcHandler负责处理网络IO事件，接收RPC调用请求，并通过Dispatcher派发消息

这里说一下Dispatcher 该类主要负责Rpc消息路由 里面有一个内部累EndPointData 但是有一个现成安全的Inbox这里面存放的时候收到的消息，非常重要后面会做具体分析

private class EndpointData(

      val name: String,

      val endpoint: RpcEndpoint,

      val ref: NettyRpcEndpointRef) {

    val inbox = new Inbox(ref, endpoint)

  }

  private val endpoints = new ConcurrentHashMap[String, EndpointData]//存放name->对应的EndPoint的信息

  private val endpointRefs = new ConcurrentHashMap[RpcEndpoint, RpcEndpointRef]//存放RpcEndpoint, RpcEndpointRef的映射关系

  private val receivers = new LinkedBlockingQueue[EndpointData]//队列下面会有一个现成不断的从里面取出来处理

 def registerRpcEndpoint(name: String, endpoint: RpcEndpoint): NettyRpcEndpointRef = {

    val addr = RpcEndpointAddress(nettyEnv.address, name)

    val endpointRef = new NettyRpcEndpointRef(nettyEnv.conf, addr, nettyEnv)

    synchronized {

      if (stopped) {

        throw new IllegalStateException("RpcEnv has been stopped")

      }

      if (endpoints.putIfAbsent(name, new EndpointData(name, endpoint, endpointRef)) != null) {

        throw new IllegalArgumentException(s"There is already an RpcEndpoint called $name")

      }

      val data = endpoints.get(name)

      endpointRefs.put(data.endpoint, data.ref)

      receivers.offer(data)  // for the OnStart message

    }

    endpointRef

  }

//注册RpcEndPoint在这里面发生 同时将data put到receivers 

在NettyRpcEndPoint里面有一个threadpool

private val threadpool: ThreadPoolExecutor = {

    val numThreads = nettyEnv.conf.getInt("spark.rpc.netty.dispatcher.numThreads",

      math.max(2, Runtime.getRuntime.availableProcessors()))

    val pool = ThreadUtils.newDaemonFixedThreadPool(numThreads, "dispatcher-event-loop")

    for (i <- 0 until numThreads) {

      pool.execute(new MessageLoop)

    }

    pool

  }

MessageLoop 是一个实现了Runnable的类，里面的run方法里面不断从receivers取出来进行处理

重要代码  data.inbox.process(Dispatcher.this)

这个里面有一个非常重要的点就是 什么时候调用onStart的方法因为receivers里面存放的是EndPoint的信息 同时创建EndPointData对象

进入Inbox里面看一下

  inbox =>  // Give this an alias so we can use it more clearly in closures.

  @GuardedBy("this")

  protected val messages = new java.util.LinkedList[InboxMessage]()

 inbox.synchronized {

    messages.add(OnStart)

  }

创建这个类的时候会有一个messagelinkedList的list集合 在创建这个结合之后 就会将onStart方法添加到里面，并且是现成安全的

然后process 方法里面会不断的拿到集合的数据来进行对应的操作

 case OnStart =>

            endpoint.onStart()

            if (!endpoint.isInstanceOf[ThreadSafeRpcEndpoint]) {

              inbox.synchronized {

                if (!stopped) {

                  enableConcurrent = true

                }

              }

            }

这个时候就会调用onStart方法

这个时候相当于RpcEndPoint可以接受消息并且处理了

Spark Rpc通信方式 分为本地消息和远程消息，本地消息相当于调用的方法直接存放到Index（中文收件箱），远程消息需要走NettyRpcHandler

以上就是如何进行Spark底层通信RPC源码分析，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注亿速云行业资讯频道。