Dubbo相关问题如何用管程实现异步转同步？

曾经终败给现在 2023-07-22 09:24 90阅读 0赞

[https://blog.csdn.net/u011296165/article/details/90199145][https_blog.csdn.net_u011296165_article_details_90199145]

总览  
Dubbo在调用服务的时候使用了DefaultFuture这个类，其中有一个概念是异步调用转成同步调用。核心思想就是管程。而实现方式就是使用lock和condition。  
condition 是java 并发包中的一个类， 在java内置管程中是一个条件变量的，而condition是可以实现一个管程多个条件变量。 lock是java的重入锁。  
关于管程和condtion可以参考：https://blog.csdn.net/u011296165/article/details/89944540  
关于lock重入锁可以参考 ： https://blog.csdn.net/u011296165/article/details/89873493  
java 并发包是使用lock和condition实现的管程。

关于同步异步  
在调用方法的时候，调用方是否需要等待返回结果才能执行下一步。如果需要等待就是同步，不需要等待就是异步。  
关于java异步方式实现有两种方式

调用方创建一个线程，这种调用我们称为异步调用。  
实现方法的时候开启一个线程去执行主要逻辑 ，主线程直接return，这种方法我们称为异步方法。  
dubbo源码  
以下是dubbo的源码，我自己跟了一点点代码，并将代码注释，一部分引入了别的累的东西，我将代码截图粘到下面

/**
     * DefaultFuture.
     */
    public class DefaultFuture implements ResponseFuture {
    
        private static final Logger logger = LoggerFactory.getLogger(DefaultFuture.class);
    
        /**
         * @Author 田培融
         * @Description 管程去调用远程服务
         * @Date 18:31 2019/5/15
         * @Param
         * @return
         **/
        private static final Map<Long, Channel> CHANNELS = new ConcurrentHashMap<>();
    
        /**
         * @Author 田培融
         * @Description 多个线程去调用返回不同的结果
         * @Date 18:31 2019/5/15
         * @Param
         * @return
         **/
        private static final Map<Long, DefaultFuture> FUTURES = new ConcurrentHashMap<>();
    
        // 超时时间
        public static final Timer TIME_OUT_TIMER = new HashedWheelTimer(
                new NamedThreadFactory("dubbo-future-timeout", true),
                30,
                TimeUnit.MILLISECONDS);
    
        // invoke id.
        private final long id;
        // dubbo 自定义的管道
        private final Channel channel;
        // dubbo 自定义的请求对象
        private final Request request;
        // 超时时间
        private final int timeout;
        // java并发包中的重入锁(管程中的入口队列和看门人)
        private final Lock lock = new ReentrantLock();
        // java并发包中的条件变量（管程中的条件变量队列）
        private final Condition done = lock.newCondition();
        // 开始时间
        private final long start = System.currentTimeMillis();
        // 使用volatile关键字去修饰以达到多线程内存可见
        private volatile long sent;
        // dubbo 自定义的响应体
        private volatile Response response;
    
        // dubbo中自定义的响应体回调接口
        private volatile ResponseCallback callback;
    
        /**
         * @Author 田培融
         * @Description 构造方法，需要传
         * @Date 18:38 2019/5/15
         * @Param [channel, request, timeout]
         * @return
         **/
        private DefaultFuture(Channel channel, Request request, int timeout) {
            this.channel = channel;
            this.request = request;
            this.id = request.getId();
            this.timeout = timeout > 0 ? timeout : channel.getUrl().getPositiveParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
            // put into waiting map.
            FUTURES.put(id, this);
            CHANNELS.put(id, channel);
        }
    
        /**
         * check time out of the future
         */
        private static void timeoutCheck(DefaultFuture future) {
            TimeoutCheckTask task = new TimeoutCheckTask(future);
            TIME_OUT_TIMER.newTimeout(task, future.getTimeout(), TimeUnit.MILLISECONDS);
        }
    
        /**
         * init a DefaultFuture
         * 1.init a DefaultFuture
         * 2.timeout check
         *
         * @param channel channel
         * @param request the request
         * @param timeout timeout
         * @return a new DefaultFuture
         */
        public static DefaultFuture newFuture(Channel channel, Request request, int timeout) {
            final DefaultFuture future = new DefaultFuture(channel, request, timeout);
            // timeout check
            timeoutCheck(future);
            return future;
        }
    
        /**
         * @Author 田培融
         * @Description 在futuresMap中获取
         * @Date 18:57 2019/5/15
         * @Param [id]
         * @return org.apache.dubbo.remoting.exchange.support.DefaultFuture
         **/
        public static DefaultFuture getFuture(long id) {
            return FUTURES.get(id);
        }
    
        /**
         * @Author 田培融
         * @Description 判断channel是否在管道map中
         * @Date 18:58 2019/5/15
         * @Param [channel]
         * @return boolean
         **/
        public static boolean hasFuture(Channel channel) {
            return CHANNELS.containsValue(channel);
        }
    
        /**
         * @Author 田培融
         * @Description 发送请求
         * 1. 先在futures队列中获取futures 在调用 dosent方法将sent值设置为当前系统时间
         * @Date 18:59 2019/5/15
         * @Param [channel, request]
         * @return void
         **/
        public static void sent(Channel channel, Request request) {
            DefaultFuture future = FUTURES.get(request.getId());
            if (future != null) {
                future.doSent();
            }
        }
    
        /**
         * close a channel when a channel is inactive
         * directly return the unfinished requests.
         * 关闭管程
         *
         * @param channel channel to close
         */
        public static void closeChannel(Channel channel) {
            for (Map.Entry<Long, Channel> entry : CHANNELS.entrySet()) {
                if (channel.equals(entry.getValue())) {
                    DefaultFuture future = getFuture(entry.getKey());
                    if (future != null && !future.isDone()) {
                        Response disconnectResponse = new Response(future.getId());
                        disconnectResponse.setStatus(Response.CHANNEL_INACTIVE);
                        disconnectResponse.setErrorMessage("Channel " +
                                channel +
                                " is inactive. Directly return the unFinished request : " +
                                future.getRequest());
                        DefaultFuture.received(channel, disconnectResponse);
                    }
                }
            }
        }
    
        /**
         * @Author 田培融
         * @Description 在响应中取值 如果就调用doReceived释放掉在条件对列中等待的线程
         * @Date 19:09 2019/5/15
         * @Param [channel, response]
         * @return void
         **/
        public static void received(Channel channel, Response response) {
            try {
                DefaultFuture future = FUTURES.remove(response.getId());
                if (future != null) {
                    future.doReceived(response);
                } else {
                    logger.warn("The timeout response finally returned at "
                            + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()))
                            + ", response " + response
                            + (channel == null ? "" : ", channel: " + channel.getLocalAddress()
                            + " -> " + channel.getRemoteAddress()));
                }
            } finally {
                CHANNELS.remove(response.getId());
            }
        }
    
        @Override
        public Object get() throws RemotingException {
            return get(timeout);
        }
    
        /**
         * @Author 田培融
         * @Description 线程通过这个方法去获取响应
         * @Date 19:22 2019/5/15
         * @Param [timeout]
         * @return java.lang.Object
         **/
        @Override
        public Object get(int timeout) throws RemotingException {
            if (timeout <= 0) {
                timeout = DEFAULT_TIMEOUT;
            }
            if (!isDone()) {
                long start = System.currentTimeMillis();
                lock.lock();
                try {
                    while (!isDone()) {
                        done.await(timeout, TimeUnit.MILLISECONDS);
                        if (isDone() || System.currentTimeMillis() - start > timeout) {
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    lock.unlock();
                }
                if (!isDone()) {
                    throw new TimeoutException(sent > 0, channel, getTimeoutMessage(false));
                }
            }
            return returnFromResponse();
        }
    
        public void cancel() {
            Response errorResult = new Response(id);
            errorResult.setErrorMessage("request future has been canceled.");
            response = errorResult;
            FUTURES.remove(id);
            CHANNELS.remove(id);
        }
    
        @Override
        public boolean isDone() {
            return response != null;
        }
    
        /**
         * @Author 田培融
         * @Description 线程通过这个方法去将直接获取到的响应结果放到这个类中的成员变量，并去唤醒在条件队列中等待的线程
         * @Date 19:25 2019/5/15
         * @Param [callback]
         * @return void
         **/
        @Override
        public void setCallback(ResponseCallback callback) {
            if (isDone()) {
                invokeCallback(callback);
            } else {
                boolean isdone = false;
                lock.lock();
                try {
                    if (!isDone()) {
                        this.callback = callback;
                    } else {
                        isdone = true;
                    }
                } finally {
                    lock.unlock();
                }
                if (isdone) {
                    invokeCallback(callback);
                }
            }
        }
    
        private static class TimeoutCheckTask implements TimerTask {
    
            private DefaultFuture future;
    
            TimeoutCheckTask(DefaultFuture future) {
                this.future = future;
            }
    
            @Override
            public void run(Timeout timeout) {
                if (future == null || future.isDone()) {
                    return;
                }
                // create exception response.
                Response timeoutResponse = new Response(future.getId());
                // set timeout status.
                timeoutResponse.setStatus(future.isSent() ? Response.SERVER_TIMEOUT : Response.CLIENT_TIMEOUT);
                timeoutResponse.setErrorMessage(future.getTimeoutMessage(true));
                // handle response.
                DefaultFuture.received(future.getChannel(), timeoutResponse);
    
            }
        }
    
        /**
         * @Author 田培融
         * @Description 直正去执行获取到的返回值放到response中
         * @Date 19:25 2019/5/15
         * @Param [c]
         * @return void
         **/
        private void invokeCallback(ResponseCallback c) {
            ResponseCallback callbackCopy = c;
            if (callbackCopy == null) {
                throw new NullPointerException("callback cannot be null.");
            }
            Response res = response;
            if (res == null) {
                throw new IllegalStateException("response cannot be null. url:" + channel.getUrl());
            }
    
            if (res.getStatus() == Response.OK) {
                try {
                    callbackCopy.done(res.getResult());
                } catch (Exception e) {
                    logger.error("callback invoke error .result:" + res.getResult() + ",url:" + channel.getUrl(), e);
                }
            } else if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
                try {
                    TimeoutException te = new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());
                    callbackCopy.caught(te);
                } catch (Exception e) {
                    logger.error("callback invoke error ,url:" + channel.getUrl(), e);
                }
            } else {
                try {
                    RuntimeException re = new RuntimeException(res.getErrorMessage());
                    callbackCopy.caught(re);
                } catch (Exception e) {
                    logger.error("callback invoke error ,url:" + channel.getUrl(), e);
                }
            }
        }
    
        private Object returnFromResponse() throws RemotingException {
            Response res = response;
            if (res == null) {
                throw new IllegalStateException("response cannot be null");
            }
            if (res.getStatus() == Response.OK) {
                return res.getResult();
            }
            if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
                throw new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());
            }
            throw new RemotingException(channel, res.getErrorMessage());
        }
    
        private long getId() {
            return id;
        }
    
        private Channel getChannel() {
            return channel;
        }
    
        private boolean isSent() {
            return sent > 0;
        }
    
        public Request getRequest() {
            return request;
        }
    
        private int getTimeout() {
            return timeout;
        }
    
        private long getStartTimestamp() {
            return start;
        }
    
        private void doSent() {
            sent = System.currentTimeMillis();
        }
    
       /**
        * @Author 田培融
        * @Description 实现管程的一部分，直释放到等待的线程
        * @Date 19:29 2019/5/15
        * @Param [res]
        * @return void
        **/
        private void doReceived(Response res) {
            lock.lock();
            try {
                response = res;
                done.signalAll();
            } finally {
                lock.unlock();
            }
            if (callback != null) {
                invokeCallback(callback);
            }
        }
    
        private String getTimeoutMessage(boolean scan) {
            long nowTimestamp = System.currentTimeMillis();
            return (sent > 0 ? "Waiting server-side response timeout" : "Sending request timeout in client-side")
                    + (scan ? " by scan timer" : "") + ". start time: "
                    + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date(start))) + ", end time: "
                    + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date())) + ","
                    + (sent > 0 ? " client elapsed: " + (sent - start)
                    + " ms, server elapsed: " + (nowTimestamp - sent)
                    : " elapsed: " + (nowTimestamp - start)) + " ms, timeout: "
                    + timeout + " ms, request: " + request + ", channel: " + channel.getLocalAddress()
                    + " -> " + channel.getRemoteAddress();
        }
    }

获取request中的id

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyOTYxNjU_size_16_color_FFFFFF_t_70][]  
将id值 初始化进入Response中

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyOTYxNjU_size_16_color_FFFFFF_t_70 1][]  
现在将代码需求重新说一下，就是线程T1在调用 Rpc之后就将线程阻塞住，当返回结果后就在将T1线程唤醒。这里使用的是管程，。因为业务牵扯过多，为了节省时间就把关于管程的代码就节取了出来 。

// 创建锁与条件变量
    private final Lock lock 
        = new ReentrantLock();
    private final Condition done 
        = lock.newCondition();
        private 
     private volatile Response response;
     
    // 调用方通过该方法等待结果
    Object get(int timeout){
      long start = System.nanoTime();
      lock.lock();
      try {
        while (!isDone()) {
          done.await(timeout);
          long cur=System.nanoTime();
          if (isDone() || 
              cur-start > timeout){
            break;
          }
        }
      } finally {
        lock.unlock();
      }
      if (!isDone()) {
        throw new TimeoutException();
      }
      return returnFromResponse();
    }
    // RPC 结果是否已经返回
    boolean isDone() {
      return response != null;
    }
    // RPC 结果返回时调用该方法   
    private void doReceived(Response res) {
      lock.lock();
      try {
        response = res;
        if (done != null) {
          done.signal();
        }
      } finally {
        lock.unlock();
      }
    }

代码流程分析  
线程T1在调用 get()方法后调用 lock锁进入管程，使用while()循环进入等待。使用finally调用释放锁。 当rpc返回结果后在调用doReceived()方法进行附值。并能知条件变量中等待的线程。

这里在对成员变量的修饰符进行解释

假如T2线程为rpc线程，T2线程会接收一个t1线程new出的对象。并将对象放到自己的线程栈内存中，因此lock需要使用final修饰(final 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。)Lock就是一个引用类型的变量这样t2线程中的lock变量就是指向的t1线程中new出的Lock对象。

response是用volatile修饰的，当t2线程获取值并对response进行操作后，response由于volatile修改，因此t1线程也可以读取到。这里是使用volatile修改的变量保证了内存可见性，就是说volatile修改的变量，线程都会去堆内存中去直接操作，而不是将变量拉到栈空间中操作。这样所有的线程都是操作的同一个变量。  
————————————

[https_blog.csdn.net_u011296165_article_details_90199145]: https://blog.csdn.net/u011296165/article/details/90199145
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyOTYxNjU_size_16_color_FFFFFF_t_70]: /images/20230528/d975ff2cbe8e473dab7eb1ad4b92897a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEyOTYxNjU_size_16_color_FFFFFF_t_70 1]: /images/20230528/6335a4bf29604f7ca5d72954f239ef6e.png