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 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM