dubbo方法调用的timeout设置

方法调用的默认超时时间为1s，但是具体的超时时间受限于服务端方法性能、服务端个数、客户端的并发数等因素，所以超时时间需要根据不同的场景进行调试。

基本步骤为：

1. 测试服务端的TPS，单位为 任务数或线程个数/S，即每秒能够处理的任务数。TPS能够表示出每秒能够处理的任务个数。
2. 根据客户端的并发量要求和服务端的服务能力设置超时时间。例如客户端并发量为R，单个服务端的服务能力为T，服务端的个数为N，那么超时时间 = R/(T*N) 。

具体调试步骤参考如下：

• 使用多线程机制测试服务端接口的TPS。我使用单元测试进行的测试，UserTestInstance可以用作中使用的XXXService可以使用dubbo接口的服务注入，也可以注入服务端的服务。 
  Java代码  

  1. package tps;  
  2.   
  3. import org.junit.After;  
  4. import org.junit.Before;  
  5. import org.junit.Test;  
  6. import org.springframework.beans.factory.annotation.Autowired;  
  7. import tps.support.DubboFutureTask;  
  8. import tps.support.DubboThread;  
  9.   
  10. import java.util.ArrayList;  
  11. import java.util.List;  
  12. import java.util.concurrent.ExecutorService;  
  13. import java.util.concurrent.Executors;  
  14.   
  15. /** 
  16.  * Created by admin on 2015-12-27. 
  17.  */  
  18. public class UserTestInstance {  
  19.   
  20.     @Autowired  
  21.     private XXXService xxxService ;  
  22.   
  23.     private static int num = 500 ;  
  24.   
  25.     //默认使用和线程个数相同的线程池，避免线程等待的时间  
  26.     private ExecutorService executorService = Executors.newFixedThreadPool(num);  
  27.   
  28.     //存储线程任务  
  29.     private List<DubboFutureTask> futureTasks = new ArrayList<>(num) ;  
  30.   
  31.     private long startTime ;  
  32.   
  33.     @Before  
  34.     public void startTime(){  
  35.         System.out.println() ;  
  36.         System.out.println("初始化调用线程。");  
  37.   
  38.         for (int i=0 ; i<num ; i++){  
  39.             DubboThread dubboThread = new DubboThread() ;  
  40.             dubboThread.setXXXService(xxxService) ;  
  41.             dubboThread.setName("thread->"+(i+1));  
  42.             //创建异步任务  
  43.             DubboFutureTask futureTask = new DubboFutureTask(dubboThread) ;  
  44.   
  45.             futureTasks.add(futureTask) ;  
  46.         }  
  47.         //创建完任务之后，开始计时  
  48.         startTime = System.currentTimeMillis() ;  
  49.     }  
  50.   
  51.     @After  
  52.     public void endTime(){  
  53.         boolean flag = true ;  
  54.   
  55.         while (flag){  
  56.             flag = false ;  
  57.             for (DubboFutureTask futureTask : futureTasks) {  
  58.                 //如果有一个没完成，则继续执行  
  59.                 if(!futureTask.isDone()){  
  60.                     flag = true ;  
  61.                     break ;  
  62.                 }  
  63.             }  
  64.         }  
  65.   
  66.         //等待所有任务完成之后，停止计时  
  67.         double consumeTime = (System.currentTimeMillis() - startTime)/1000.0 ;  
  68.   
  69.         System.out.println("线程数："+futureTasks.size()+" , 共消耗时间："+consumeTime+"s" +" , 异常数量："+DubboThread.TIMEOUT_NUM.get());  
  70.   
  71.         System.out.println("TPS："+num/consumeTime);  
  72.     }  
  73.   
  74.     @Test  
  75.     public void testTPS(){  
  76.         //提交任务请求到线程池  
  77.         for (DubboFutureTask futureTask : futureTasks) {  
  78.             executorService.submit(futureTask) ;  
  79.         }  
  80.   
  81.     }  
  82. }  
   
  Java代码  

  1. package tps.support;  
  2.   
  3. import lombok.Getter;  
  4. import lombok.Setter;  
  5.   
  6. import java.util.concurrent.FutureTask;  
  7.   
  8. /** 
  9.  * Created by admin on 2015-12-27. 
  10.  */  
  11. @Setter  
  12. @Getter  
  13. public class DubboFutureTask extends FutureTask<Object> {  
  14.   
  15.     private DubboThread dubboThread ;  
  16.   
  17.     public DubboFutureTask(DubboThread dubboThread) {  
  18.         super(dubboThread) ;  
  19.         this.dubboThread = dubboThread ;  
  20.     }  
  21. }  
   
  Java代码  

  1. package tps.support;  
  2.   
  3. import com.glodon.framework.common.util.JsonMapper;  
  4. import lombok.Getter;  
  5. import lombok.Setter;  
  6.   
  7. import java.util.concurrent.Callable;  
  8. import java.util.concurrent.atomic.AtomicInteger;  
  9.   
  10. /** 
  11.  * Created by admin on 2015-12-21. 
  12.  */  
  13. @Setter  
  14. @Getter  
  15. public class DubboThread implements Callable<Object> {  
  16.   
  17.     public static final AtomicInteger TIMEOUT_NUM = new AtomicInteger(0) ;  
  18.   
  19.     private XXXService xxxService ;  
  20.   
  21.     private String name ;  
  22.   
  23.     @Override  
  24.     public Object call() throws Exception {  
  25.         XXXEntity xxx = null ;  
  26.         try {  
  27.             xxx= xxxService.login("superman" , "123456") ;  
  28.             System.out.println("线程名称-> "+getName()+" -> "+ JsonMapper.toJSONString(xxx));  
  29.         }catch (Exception e){  
  30.             //异常数量  
  31.             TIMEOUT_NUM.incrementAndGet() ;  
  32.             e.printStackTrace();  
  33.         }  
  34.   
  35.         return xxx ;  
  36.     }  
  37. }  
   
• 根据服务端性能、个数和客户端的并发要求，就可以计算出具体的timeout的值了。
• dubbo用户手册 ： http://dubbo.io/User+Guide-zh.htm 

转载于:https://www.cnblogs.com/austinspark-jessylu/p/7793370.html