ThreadPoolTaskExecutor 多线程分解执行耗时任务与单线程串行执行简单比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import  java.util.ArrayList;
import  java.util.List;
import  java.util.concurrent.Callable;
import  java.util.concurrent.ExecutionException;
import  java.util.concurrent.Future;
import  java.util.concurrent.ThreadPoolExecutor;
import  java.util.concurrent.TimeUnit;
 
import  org.apache.commons.lang.StringUtils;
import  org.apache.commons.lang.exception.ExceptionUtils;
import  org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
/**
  * <pre>
  *
  * @author tangxiaodong
  * 创建日期: 2014年11月18日
  * </pre>
  */
public  class  TaskTest {
 
     /**
      * @param args
      * @throws ExecutionException 
      * @throws InterruptedException 
      */
     public  static  void  main(String[] args)  throws  InterruptedException, ExecutionException {
         System.out.println( "testNoThreadTask begin ..." );
         testNoThreadTask();
         
         FdfcUtil.sleep( 1 );
         
         System.out.println( "testThreadTask begin ..." );
         testThreadTask();
     }
     
     private  static  void  testNoThreadTask() {
         long  t1 = System.currentTimeMillis();
         for  ( int  k =  0 ; k <  10 ; k++) {
             // 这是一个耗时的工作
             FdfcUtil.sleep((k +  1 ) *  500 );
             System.out.println( " k="  + k);
             System.out.println( "k="  + k +  " success" );
         }
         System.out.println( " times :" );
         System.out.println(System.currentTimeMillis() - t1);
     }
     
     
     private  static  void  testThreadTask(){
         
         // TODO Auto-generated method stub
         ThreadPoolTaskExecutor executor =  new  ThreadPoolTaskExecutor();
         executor.setCorePoolSize( 2 );
         executor.setMaxPoolSize( 4 );
         executor.setKeepAliveSeconds( 120 );
         executor.setQueueCapacity( 32 );
         executor.setRejectedExecutionHandler( new  ThreadPoolExecutor.CallerRunsPolicy());
         executor.initialize();
         
         List<Future<String>> taskResults =  new  ArrayList<Future<String>>();
         long  t1 = System.currentTimeMillis();
         for ( int  k= 0 ; k< 10 ; k++){
             taskResults.add(process(executor, k));
         }
         System.out.println( "task doing ..." );
         while  ( true ) {
             boolean  isAllDone =  true ;
             for  (Future<String> taskResult : taskResults) {
                 isAllDone &= ( taskResult.isDone() || taskResult.isCancelled() );
             }
             if  (isAllDone) {
                 // 任务都执行完毕,跳出循环
                 break ;
             }
             try  {
                 System.out.println( "waiting and sleep 1000 ..." );
                 TimeUnit.MILLISECONDS.sleep( 1000 );
             catch  (Exception e) {
                 System.out.println(e.toString());
                 break ;
             }
         }
         
         for (Future<String> taskResult : taskResults){
             String ex;
             try  {
                 ex = taskResult.get();
             catch  (Exception e) {
                 ex = ExceptionUtils.getFullStackTrace(e);
             }
             if (StringUtils.isNotEmpty(ex)){
                 System.out.println(ex);
             }
         }
         System.out.println( " times :" );
         System.out.println(System.currentTimeMillis()-t1);
     }
 
     private  static  Future<String> process( final  ThreadPoolTaskExecutor executor ,  final  int  k) {
         return  executor.submit( new  Callable<String>() {
             @Override
             public  String call()  throws  Exception {
                 try  {
                     FdfcUtil.sleep((k+ 1 )* 500 );
                     System.out.println( " k="  + k);
                 catch  (Exception e) {
                     return  ExceptionUtils.getFullStackTrace(e);
                 }
                 return  "k="  + k +  " success" ;
             }
         });
     }
}

testNoThreadTask  耗时:

times : 27996 ms

testThreadTask 耗时:

times : 15239 ms

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值