码迷,mamicode.com
首页 > 其他好文 > 详细

dubbo_远程同步调用原理

时间:2016-07-17 12:52:05      阅读:506      评论:0      收藏:0      [点我收藏+]

标签:

Dubbo缺省协议采用单一长连接和NIO异步通讯,适合于小数据量大并发的服务调用,以及服务消费者机器数远大于服务提供者机器数的情况。

 

技术分享

Dubbo缺省协议,使用基于mina1.1.7+hessian3.2.1的tbremoting交互。

  • 连接个数:单连接
  • 连接方式:长连接
  • 传输协议:TCP
  • 传输方式:NIO异步传输
  • 序列化:Hessian二进制序列化
  • 适用范围:传入传出参数数据包较小(建议小于100K),消费者比提供者个数多,单一消费者无法压满提供者,尽量不要用dubbo协议传输大文件或超大字符串
  • 适用场景:常规远程服务方法调用

 通常,一个典型的同步远程调用应该是这样的:

1, 客户端线程调用远程接口,向服务端发送请求,同时当前线程应该处于“暂停“状态,即线程不能向后执行了,必需要拿到服务端给自己的结果后才能向后执行
2, 服务端接到客户端请求后,处理请求,将结果给客户端

3, 客户端收到结果,然后当前线程继续往后执行

 

Dubbo里使用到了Socket(采用apache mina框架做底层调用)来建立长连接,发送、接收数据,底层使用apache mina框架的IoSession进行发送消息。 
Dubbo底层使用Socket发送消息的形式进行数据传递,结合了mina框架,使用IoSession.write()方法,这个方法调用后对于整个远程调用(从发出请求到接收到结果)来说是一个异步的,即对于当前线程来说,将请求发送出来,线程就可以往后执行了,至于服务端的结果,是服务端处理完成后,再以消息的形式发送给客户端的。
于是这里出现了2个问题:
  • 当前线程怎么让它“暂停”,等结果回来后,再向后执行?
  • 正如前面所说,Socket通信是一个全双工的方式,如果有多个线程同时进行远程方法调用,这时建立在client server之间的socket连接上会有很多双方发送的消息传递,前后顺序也可能是乱七八糟的,server处理完结果后,将结果消息发送给client,client收到很多消息,怎么知道哪个消息结果是原先哪个线程调用的?
   基本原理如下:
  1. client一个线程调用远程接口,生成一个唯一的ID(比如一段随机字符串,UUID等),Dubbo是使用AtomicLong从0开始累计数字的
  2. 将打包的方法调用信息(如调用的接口名称,方法名称,参数值列表等),和处理结果的回调对象callback,全部封装在一起,组成一个对象object
  3. 向专门存放调用信息的全局ConcurrentHashMap里面put(ID, object)
  4. ID和打包的方法调用信息封装成一对象connRequest,使用IoSession.write(connRequest)异步发送出去
  5. 当前线程再使用callback的get()方法试图获取远程返回的结果,在get()内部,则使用synchronized获取回调对象callback的锁, 再先检测是否已经获取到结果,如果没有,然后调用callback的wait()方法,释放callback上的锁,让当前线程处于等待状态。
  6. 服务端接收到请求并处理后,将结果(此结果中包含了前面的ID,即回传)发送给客户端,客户端socket连接上专门监听消息的线程收到消息,分析结果,取到ID,再从前面的ConcurrentHashMap里面get(ID),从而找到callback,将方法调用结果设置到callback对象里。
  7. 监听线程接着使用synchronized获取回调对象callback的锁(因为前面调用过wait(),那个线程已释放callback的锁了),再notifyAll(),唤醒前面处于等待状态的线程继续执行(callback的get()方法继续执行就能拿到调用结果了),至此,整个过程结束。

   需要注意的是,这里的callback对象是每次调用产生一个新的,不能共享,否则会有问题;另外ID必需至少保证在一个Socket连接里面是唯一的。

 

现在,前面两个问题已经有答案了,

 

  • 当前线程怎么让它“暂停”,等结果回来后,再向后执行?
     答:先生成一个对象obj,在一个全局map里put(ID,obj)存放起来,再用synchronized获取obj锁,再调用obj.wait()让当前线程处于等待状态,然后另一消息监听线程等到服务端结果来了后,再map.get(ID)找到obj,再用synchronized获取obj锁,再调用obj.notifyAll()唤醒前面处于等待状态的线程。
  • 正如前面所说,Socket通信是一个全双工的方式,如果有多个线程同时进行远程方法调用,这时建立在client server之间的socket连接上会有很多双方发送的消息传递,前后顺序也可能是乱七八糟的,server处理完结果后,将结果消息发送给client,client收到很多消息,怎么知道哪个消息结果是原先哪个线程调用的?

 

       答:使用一个ID,让其唯一,然后传递给服务端,再服务端又回传回来,这样就知道结果是原先哪个线程的了。
 

另外:

   服务端在处理客户端的消息,然后再处理时,使用了线程池来并行处理,不用一个一个消息的处理

   同样,客户端接收到服务端的消息,也是使用线程池来处理消息,再回调

   消息中间件rabbitmq远程接口调用,同步调用的原理跟这类似,详见:rabbitmq 学习-9- RpcClient发送消息和同步接收消息原理
 
关键代码:
com.taobao.remoting.impl.DefaultClient.java
//同步调用远程接口
public Object invokeWithSync(Object appRequest, RequestControl control) throws RemotingException, InterruptedException {
        byte protocol = getProtocol(control);
        if (!TRConstants.isValidProtocol(protocol)) {
            throw new RemotingException("Invalid serialization protocol [" + protocol + "] on invokeWithSync.");
        }
        ResponseFuture future = invokeWithFuture(appRequest, control);
        return future.get();  //获取结果时让当前线程等待,ResponseFuture其实就是前面说的callback
}
public ResponseFuture invokeWithFuture(Object appRequest, RequestControl control) {
         byte protocol = getProtocol(control);
         long timeout = getTimeout(control);
         ConnectionRequest request = new ConnectionRequest(appRequest);
         request.setSerializeProtocol(protocol);
         Callback2FutureAdapter adapter = new Callback2FutureAdapter(request);
         connection.sendRequestWithCallback(request, adapter, timeout);
         return adapter;
}
Callback2FutureAdapter implements ResponseFuture
public Object get() throws RemotingException, InterruptedException {
 synchronized (this) {  // 旋锁
     while (!isDone) {  // 是否有结果了
  wait(); //没结果是释放锁,让当前线程处于等待状态
     }
 }
 if (errorCode == TRConstants.RESULT_TIMEOUT) {
     throw new TimeoutException("Wait response timeout, request["
      + connectionRequest.getAppRequest() + "].");
 }
 else if (errorCode > 0) {
     throw new RemotingException(errorMsg);
 }
 else {
     return appResp;
 }
}
客户端收到服务端结果后,回调时相关方法,即设置isDone = true并notifyAll()
public void handleResponse(Object _appResponse) {
         appResp = _appResponse; //将远程调用结果设置到callback中来
         setDone();
}
public void onRemotingException(int _errorType, String _errorMsg) {
         errorCode = _errorType;
         errorMsg = _errorMsg;
         setDone();
}
private void setDone() {
         isDone = true;
         synchronized (this) { //获取锁,因为前面wait()已经释放了callback的锁了
             notifyAll(); // 唤醒处于等待的线程
         }
}
CallbackExecutorTask
static private class CallbackExecutorTask implements Runnable {
         final ConnectionResponse resp;
         final ResponseCallback callback;
         final Thread createThread;
 
         CallbackExecutorTask(ConnectionResponse _resp, ResponseCallback _cb) {
             resp = _resp;
             callback = _cb;
             createThread = Thread.currentThread();
         }
 
         public void run() {
             // 预防这种情况:业务提供的Executor,让调用者线程来执行任务
             if (createThread == Thread.currentThread()
                       && callback.getExecutor() != DIYExecutor.getInstance()) {
                   StringBuilder sb = new StringBuilder();
                   sb.append("The network callback task [" + resp.getRequestId() + "] cancelled, cause:");
                   sb.append("Can not callback task on the network io thhread.");
                   LOGGER.warn(sb.toString());
                   return;
             }
 
             if (TRConstants.RESULT_SUCCESS == resp.getResult()) {
                   callback.handleResponse(resp.getAppResponse()); //设置调用结果
             }
             else {
                   callback.onRemotingException(resp.getResult(), resp
                            .getErrorMsg());  //处理调用异常
             }
         }
}

 

 
转自http://blog.163.com/tsing_hua/blog/static/1396222242012819557547/
 

 

dubbo_远程同步调用原理

标签:

原文地址:http://www.cnblogs.com/dengzy/p/5677571.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!