dubbo方法调用的timeout设置

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

基本步骤为：

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

具体调试步骤参考如下：

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

   

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

   

  1. package tps.support;
  2. import com.glodon.framework.common.util.JsonMapper;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import java.util.concurrent.Callable;
  6. import java.util.concurrent.atomic.AtomicInteger;
  7. /**
  8. * Created by admin on 2015-12-21.
  9. */
  10. @Setter
  11. @Getter
  12. public class DubboThread implements Callable<Object> {
  13. public static final AtomicInteger TIMEOUT_NUM = new AtomicInteger(0) ;
  14. private XXXService xxxService ;
  15. private String name ;
  16. @Override
  17. public Object call() throws Exception {
  18. XXXEntity xxx = null ;
  19. try {
  20. xxx= xxxService.login("superman" , "123456") ;
  21. System.out.println("线程名称-> "+getName()+" -> "+ JsonMapper.toJSONString(xxx));
  22. }catch (Exception e){
  23. //异常数量
  24. TIMEOUT_NUM.incrementAndGet() ;
  25. e.printStackTrace();
  26. }
  27. return xxx ;
  28. }
  29. }

   

• 根据服务端性能、个数和客户端的并发要求，就可以计算出具体的timeout的值了。
• dubbo用户手册 ： http://dubbo.io/User+Guide-zh.htm