Hadoop-client端ipc解析<转>

1.client运行的流程

1）创建代理对象；

2）代理对象调用相应方法（invoke()）；

3）invoke调用client对象的call方法，向服务器发送请求（参数、方法）；

4）再等待call方法的完成；

5）返回请求结果。

 

2.client主要的内部类

主要的几个类说明： 

• 1. Call，表示一次rpc的调用请求
• 2. Connection，表示一个client与server之间的连接，一个连接一个线程启动
• 3. ConnectionId：连接的标记（包括server地址，协议，其他一些连接的配置项信息）
• 4. ParallelCall：实现并行调用的请求
• 5. ParallelResults：并行调用的执行结果

 

3.client调用过程

3.0一个实际的调用

在DFSclient中

return (ClientDatanodeProtocol)RPC.getProxy(ClientDatanodeProtocol.class,
      ClientDatanodeProtocol.versionID, addr, conf);

3.1生成代理

public static VersionedProtocol getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, UserGroupInformation ticket, Configuration conf, SocketFactory factory, int rpcTimeout) throws IOException

{

    ……

    VersionedProtocol proxy = (VersionedProtocol) Proxy.newProxyInstance(protocol.getClassLoader(), new Class[] { protocol }, new Invoker(protocol, addr, ticket, conf, factory, rpcTimeout));

    ……

    return proxy;

}

其中Invoker是一个实现了InvocationHandler 接口的类

 

3.2代理对象调用相应方法（invoke()）

getProxy调用者，使用这个proxy进行任何protocol声明的函数调用，比如还是上例中DFSclient的例子，如果调用proxy.getBlockInfo(…);都会转化成调用Invoker类的invoke函数

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

{

    ……

    ObjectWritable value = (ObjectWritable) client.call(new Invocation(method, args), remoteId);

    ……

    return value.get();

}

Invocation 用于封装方法名和参数，作为数据传输层。远程调用的主要关键就是Invocation实现了Writable接口,Invocation在write(DataOutput out)函数中将调用的methodName写入到out，将调用方法的参数个数写入out ，同时逐个将参数的className写入out,最后将所有参数逐个写入out,这也就决定了通过RPC实现调用的方法中的参数要么是简单类型，要么是String,要么是实现了Writable接口的类（参数自己知道如何序列化到stream），要么是数组（数组的元素也必须为简单类型,String,实现了Writable接口的类）。

Invocation序列化参数的实现是通过如下函数实现的:org.apache.hadoop.io.ObjectWritable.writeObject

public void write(DataOutput out) throws IOException
{
    UTF8.writeString(out, methodName);
    out.writeInt(parameterClasses.length);
    for (int i = 0; i < parameterClasses.length; i++)
    {
        ObjectWritable.writeObject(out, parameters[i], parameterClasses[i], conf);
    }
}

 

3.3invoke调用client对象的call方法，向服务器发送请求（参数、方法）

public Writable call(Writable param, ConnectionId remoteId) throws InterruptedException, IOException
{
    Call call = new Call(param);// new Invocation(method, args)
    Connection connection = getConnection(remoteId, call);// 获得连接对象 可见一个client可以有多个connection
    connection.sendParam(call); // 将Invocation(method, args)的函数名,参数序列化发送到server端
    while (!call.done)
    {
        call.wait(); // wait for the result 调用client的线程在此阻塞
    }

    return call.value;//返回调用结果
}

 

3.4获得连接对象getConnection

private Connection getConnection(ConnectionId remoteId, Call call) throws IOException, InterruptedException
{
    Connection connection;
    do
    {
        synchronized (connections)
        {
            connection = connections.get(remoteId);
            if (connection == null)
            {
                connection = new Connection(remoteId);
                connections.put(remoteId, connection);
            }
        }
    } while (!connection.addCall(call));//可见 一个connection 可以有多个调用call
    connection.setupIOstreams();//实际进行连接 每个connection都新起一个线程
    return connection;
}

 

3.5 connection的线程等待接受结果

public void run()
{
    try
    {
        while (waitForWork())//超时检测等条件 connection close
        {// wait here for work - read or close connection
            receiveResponse();
        }
    }
    close();
}

private void receiveResponse()
{
    try
    {
        int id = in.readInt(); // try to read an id
        Call call = calls.get(id);
        int state = in.readInt(); // read call status
        if (state == Status.SUCCESS.state)
        {
            Writable value = ReflectionUtils.newInstance(valueClass, conf);
            value.readFields(in); // 将结果反序列化
            call.setValue(value);//在这里
            calls.remove(id);
        }
    } catch (IOException e)
    {
        markClosed(e);
    }
}

 

3.6返回结果,通知client线程

public synchronized void setValue(Writable value)
{
    this.value = value;
    callComplete();
}
protected synchronized void callComplete()
{
    this.done = true;
    notify(); // notify caller
}

 

4. 异步/同步模型

Hadoop的RPC对外的接口其实是同步的，但是，RPC的内部实现其实是异步消息机制。hadoop用线程wait/notify机制实现异步转同步，发送请求（call）之后wait请求处理完毕，接收完响应（connection.receiveResponse()）之后notify，notify()方法在call.setValue中。但现在有一个问题，一个connection有多个call。可能同时有多个call在等待接收消息，那么是当client接收到response后，怎样确认它到底是之前哪个request的response呢？这个就是依靠的connection中的一个HashTable<Integer, Call>了，其中的Integer是用来标识Call，这样就可以将request和response对应上了。

 

5.时序图

 

6.client类图

 

 

 

7.参考

http://weixiaolu.iteye.com/blog/1504898

http://www.wikieno.com/2012/02/hadoop-ipc-client/

http://caibinbupt.iteye.com/blog/280790

http://blog.csdn.net/sxf_824/article/details/4842153

http://blog.csdn.net/historyasamirror/article/details/6159248