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.xRpc提供了上层抽象（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 ThreadSafeRpcEndpointextends RpcEndpoint//因为receive是并发操作如果要现成安全就是用threadSafeRpcEndPoint

 

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

原因后面的源码的提到

 

RpcEndpointRef:抽象类

 

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

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

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

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

  defask[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对象

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

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

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

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

  defshutdown(): Unit//关闭RpcEndPoint

 defawaitTermination(): Unit//等待RpcEndPoint退出

 

object RpcEnv

 defcreate(

     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方法创建

 

 valnettyEnv =

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

 private val dispatcher: Dispatcher = newDispatcher(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]//队列下面会有一个现成不断的从里面取出来处理

 

 

 defregisterRpcEndpoint(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 anRpcEndpoint called $name")

      }

     val data = endpoints.get(name)

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

     receivers.offer(data)  // for theOnStart 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 aliasso 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 方法里面会不断的拿到集合的数据来进行对应的操作

 caseOnStart =>

           endpoint.onStart()

           if (!endpoint.isInstanceOf[ThreadSafeRpcEndpoint]) {

              inbox.synchronized {

                if (!stopped) {

                  enableConcurrent = true

                }

              }

           }

这个时候就会调用onStart方法

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

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