ThreadPoolExecutor关闭后如何复用代码并重新启动? 求指点

飞火流云 2016-09-26 04:18:59
在API没看到相关写法，求指点.



ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors

        .newCachedThreadPool();

    executor.setMaximumPoolSize(conf.getInt(DEFAULT_THREAD_POOL_SIZE, 64));

    executor.setRejectedExecutionHandler(retryHandler);



   executor.execute(new ComputeRunnable(XXX));

   executor.shutdown();

    try {

      executor.awaitTermination(60, TimeUnit.SECONDS);

    } catch (InterruptedException e) {

      throw new IOException(e);

    }


这段代码执行完了，希望复用executor并执行下一个多线程计算，如何重启executor 呢? ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors .newCachedThreadPool(); 这样还要再写一遍?

以下是实例代码:


package concurrencyTest;



import java.util.concurrent.Executors;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;





public class ExecutorReuse {



	/**

	 * @param args

	 */

	public static void main(String[] args) {

		 try {

			 long start = System.currentTimeMillis() ;

		 RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();

		 ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors

			        .newCachedThreadPool();

			    executor.setMaximumPoolSize(64);

			    executor.setRejectedExecutionHandler(retryHandler);

			    

	     int i = 0;

	     while (i<10000) {

	        executor.execute(new ComputeRunnable(i));

	        i++ ;

	     }

	     

	     executor.shutdown();

	     executor.awaitTermination(60, TimeUnit.SECONDS);

	     

             i=0 ;

	     while (i<100) {

		        executor.execute(new ComputeRunnable2(i));

		        i++ ;

		 }

	     executor.shutdown();

	     executor.awaitTermination(60, TimeUnit.SECONDS);

	     

	     System.out.println("Last " +( System.currentTimeMillis() - start ) +" ms");

	    } catch (Exception e) {

        e.printStackTrace() ;

     }

  }

}



class ComputeRunnable implements Runnable {

	int id = 0 ;

	

	public ComputeRunnable(int i ) {

		id = i ;

	}

	

	@Override

	public void run() {

           id =id *9 ;

//           System.out.println("ComputeRunnable1  started!");

	}

}



class ComputeRunnable2 implements Runnable {

	int id = 0 ;

	

	public ComputeRunnable2(int i ) {

		id = i ;

	}

	

	@Override

	public void run() {

           id =id *4 ;

           System.out.println("ComputeRunnable2  started!");

	}

}


结果报错！似乎只能这样写啊:




package concurrencyTest;



import java.util.concurrent.Executors;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;





public class ExecutorReuse {



	/**

	 * @param args

	 */

	public static void main(String[] args) {

		 try {

			 long start = System.currentTimeMillis() ;

		 RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();

		 ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors

			        .newCachedThreadPool();

	    executor.setMaximumPoolSize(64);

	    executor.setRejectedExecutionHandler(retryHandler);

			    

	     int i = 0;

	     while (i<10000) {

	        executor.execute(new ComputeRunnable(i));

	        i++ ;

	     }

	     

	     executor.shutdown();

	     executor.awaitTermination(60, TimeUnit.SECONDS);

	     System.out.println("First 1 Step Last " +( System.currentTimeMillis() - start ) +" ms");

	     

	     start = System.currentTimeMillis() ;

	     executor = (ThreadPoolExecutor) Executors

			        .newCachedThreadPool();

	    executor.setMaximumPoolSize(64);

	    executor.setRejectedExecutionHandler(retryHandler);

         i = 0;	     

	     while (i<1000) {

	        executor.execute(new ComputeRunnable2(i));

	        i++ ;

		 }

	     executor.shutdown();

	     executor.awaitTermination(60, TimeUnit.SECONDS);

	     System.out.println("Last " +( System.currentTimeMillis() - start ) +" ms");



	    } catch (Exception e) {

        e.printStackTrace() ;

     }

  }

}



class ComputeRunnable implements Runnable {

	int id = 0 ;

	

	public ComputeRunnable(int i ) {

		id = i ;

	}

	

	@Override

	public void run() {

           id =id *9 ;

//           System.out.println("ComputeRunnable1  started!");

	}

}



class ComputeRunnable2 implements Runnable {

	int id = 0 ;

	

	public ComputeRunnable2(int i ) {

		id = i ;

	}

	

	@Override

	public void run() {

           id =id *4 ;

//           System.out.println("ComputeRunnable2  started!");

	}

}
...全文
2055 12 打赏 收藏 举报
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
VonLippmann 2019-02-01
  • 打赏
  • 举报
 回复
如果你知道任务数，你可以在你继承的runable类里面搞一个静态变量做计数器，在run函数结束前让它加1，这个变量与你的任务数相等的时候，表明所有任务都完成了，你可以用这个作为所有子线程都结束的标志，然后不关闭线程池，在下个并行计算中，继续使用之前的线程池和任务队列。
飞火流云 2016-10-07
  • 打赏
  • 举报
 回复
引用 9 楼 rickylin86 的回复:
唉。兄弟。我建议你先了解下执行器框架.不要一见到API就用. 执行器只需要创建一个,你那样无限创建执行器一点意义都没有.
可见还是不用future接口的方法好些!
飞火流云 2016-10-07
  • 打赏
  • 举报
 回复
引用 9 楼 rickylin86 的回复:
唉。兄弟。我建议你先了解下执行器框架.不要一见到API就用. 执行器只需要创建一个,你那样无限创建执行器一点意义都没有.
不好意思，太粗心了，我试了下你的方法 两者确实都可以大量执行线程，但是使用Future接口获取结果的方法确实慢，下面是代码和测试结果: 

package concurrencyTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;


public class ConcurrentTest2 {

	public static void main(String[] args) {
		long start = System.currentTimeMillis() ;
		ConcurrentTest2 blt = new ConcurrentTest2() ;
		List<Integer> messages = new ArrayList<Integer>();
		
		for(int i =0 ;i<10000; i++) {
			 messages.add(i) ;
		}
		
		ExecutorService pool = Executors.newFixedThreadPool(64); // 并发测试
		CompletionService<Boolean> exchangeResult = new ExecutorCompletionService<Boolean>(
				pool);
		int count = 0 ;
		try {
			for(Integer i : messages) {
					Future future = exchangeResult.submit(blt.new Worker(i));
					Object result;
					result = future.get();
					if (result != null) count++ ;
			}
			pool.shutdown() ;
			pool.awaitTermination(60, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		System.out.println("Last " + (System.currentTimeMillis() - start) + " ms count: " +count);
	}

	  class Worker implements  Callable<Boolean> {
		    Integer msg;

			public Worker(Integer msg) {
				this.msg = msg;
			}
			
			@Override
			public Boolean call() throws Exception {
				try {
					 int sum = msg  ;
				} catch (Exception e) {
					e.printStackTrace() ;
				}
				return true;
			}
		}
}
Last 228 ms count: 10000 前一种方法 : 
package concurrencyTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ConcurrentTest {

	public static void main(String[] args) {
		long start = System.currentTimeMillis() ;
		ConcurrentTest blt = new ConcurrentTest() ;
		List<Integer> messages = new ArrayList<Integer>();
		
		for(int i =0 ;i<10000; i++) {
			 messages.add(i) ;
		}
		
		RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();		
	    ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors
	            .newCachedThreadPool();
	    executor.setMaximumPoolSize(64);
	    executor.setRejectedExecutionHandler(retryHandler);
	    
	     for (Integer i : messages) {
	        executor.execute(blt.new Worker(i));
	      }

	      executor.shutdown();
	      try {
	        executor.awaitTermination(60, TimeUnit.SECONDS);
	      } catch (Exception e) {
	        e.printStackTrace() ;
	      }
		
		System.out.println("Last " + (System.currentTimeMillis() - start) + " ms count: ");
	}

	  class Worker implements  Runnable {
		  Integer msg;

			public Worker(Integer msg) {
				this.msg = msg;
			}

			@Override
			public void run() {
				try {
					 int sum = msg ;
				} catch (Exception e) {
					e.printStackTrace() ;
				}
			}
		}
	
}

class RetryRejectedExecutionHandler implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
      try {
        Thread.sleep(10);
      } catch (InterruptedException e) {
        e.printStackTrace() ;
      }
      executor.execute(r);
    }
}
Last 49
rickylin86 2016-10-02
  • 打赏
  • 举报
 回复
唉。兄弟。我建议你先了解下执行器框架.不要一见到API就用. 执行器只需要创建一个,你那样无限创建执行器一点意义都没有.
飞火流云 2016-10-02
  • 打赏
  • 举报
 回复
引用 7 楼 rickylin86 的回复:
你的代码逻辑有问题.类似的逻辑应该是 

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class Test{
	public static void main(String[] args){
		int totalTask = 100;
		ExecutorService executor = Executors.newFixedThreadPool(1);
		for(int i = 0 ; i < totalTask ; i ++){
                        //伪代码
			Future future = executor.submit(Callable<Object> task);
			Object result = future.get();
		}
	}
}
本身你采用的是CachedThreadPool();你不断的提交任务那么就会不限制的创建线程执行.然后再在另一个while中get所有的结果. 按照这样的逻辑如果本身创建线程太多的话那么系统自然会受不了啦
你说的似乎有道理，但是我试了下，这样也不行: 

package concurrencyTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class ArrayTest {

	public static void main(String[] args) {
		long start = System.currentTimeMillis() ;
		ArrayTest blt = new ArrayTest() ;
		List<Integer> messages = new ArrayList<Integer>();
		
		for(int i =0 ;i<10000; i++) {
			 messages.add(i) ;
		
		ExecutorService pool = Executors.newFixedThreadPool(64); // 并发测试
		CompletionService<Boolean> exchangeResult = new ExecutorCompletionService<Boolean>(
				pool);
		int count = 0 ;
		try {
			for(Integer i : messages) {
	//				exchangeResult.submit(blt.new Worker(i));
	//				Future<Boolean> f = exchangeResult.poll();
					Future future = exchangeResult.submit(blt.new Worker(i));
					Object result;
					result = future.get();
					if (result != null) count++ ;
			}
			pool.awaitTermination(60, TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		System.out.println("Last " + (System.currentTimeMillis() - start) + " ms count: " + count);
	}

	  class Worker implements  Callable<Boolean> {
		    Integer msg;

			public Worker(Integer msg) {
				this.msg = msg;
			}
			
			@Override
			public Boolean call() throws Exception {
				try {
					 int sum = msg  ;
				} catch (Exception e) {
					e.printStackTrace() ;
				}
				return true;
			}
		} 
}
rickylin86 2016-09-27
  • 打赏
  • 举报
 回复
你的代码逻辑有问题.类似的逻辑应该是 

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class Test{
	public static void main(String[] args){
		int totalTask = 100;
		ExecutorService executor = Executors.newFixedThreadPool(1);
		for(int i = 0 ; i < totalTask ; i ++){
                        //伪代码
			Future future = executor.submit(Callable<Object> task);
			Object result = future.get();
		}
	}
}
本身你采用的是CachedThreadPool();你不断的提交任务那么就会不限制的创建线程执行.然后再在另一个while中get所有的结果. 按照这样的逻辑如果本身创建线程太多的话那么系统自然会受不了啦
飞火流云 2016-09-27
  • 打赏
  • 举报
 回复
引用 4 楼 rickylin86 的回复:
[quote=引用 3 楼 cloudeagle_bupt 的回复:] [quote=引用 1 楼 inrtyx 的回复:] 为什么要关闭？
因为两个并行性过程是有依赖关系的，需要确保前面的过程结束后才能执行后面的啊[/quote] 如果你的需求是这样的话那么不需要关闭执行器啊.采用Executor.submit(Callable<>)然后通过Future来判断是否结束. 当Future.get方法得到结果后再放入新的任务到执行器中.然后调用Executor.shutdown()就可以了.[/quote] 噢，这里我用了一些其他库定义的基本类型如IntWriable, 你可以换成其他基本类型试下代码。。。
飞火流云 2016-09-27
  • 打赏
  • 举报
 回复
引用 4 楼 rickylin86 的回复:
[quote=引用 3 楼 cloudeagle_bupt 的回复:] [quote=引用 1 楼 inrtyx 的回复:] 为什么要关闭？
因为两个并行性过程是有依赖关系的，需要确保前面的过程结束后才能执行后面的啊[/quote] 如果你的需求是这样的话那么不需要关闭执行器啊.采用Executor.submit(Callable<>)然后通过Future来判断是否结束. 当Future.get方法得到结果后再放入新的任务到执行器中.然后调用Executor.shutdown()就可以了.[/quote] 你说的很对，但是实际中发现这种方法效率非常低，我写了两段对比代码，如下; 

import java.util.ArrayList;
import java.util.List;  
import java.util.concurrent.Callable;  
import java.util.concurrent.CompletionService;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ConcurrentLinkedQueue;  
import java.util.concurrent.ExecutorCompletionService;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
import java.util.concurrent.RejectedExecutionHandler;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
  
import org.apache.hadoop.io.IntWritable;  
  
public class ArrayTest {  
  
    public static void main(String[] args) {  
        long start = System.currentTimeMillis() ;  
        ArrayTest blt = new ArrayTest() ;  
        List<IntWritable> messages = new ArrayList<IntWritable>();  
          
        for(int i =0 ;i<10000; i++) {  
             messages.add(new IntWritable(i)) ;  
        }  
//      RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();          
//      ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors  
//              .newCachedThreadPool();  
//      executor.setMaximumPoolSize(64);  
//      executor.setRejectedExecutionHandler(retryHandler);  
//        
//       for (IntWritable i : messages) {  
//          executor.execute(blt.new Worker(i));  
//        }  
//  
//        executor.shutdown();  
//        try {  
//          executor.awaitTermination(60, TimeUnit.SECONDS);  
//        } catch (Exception e) {  
//          e.printStackTrace() ;  
//        }  
          
        ExecutorService pool = Executors.newCachedThreadPool(); // 并发测试  
        CompletionService<Boolean> exchangeResult = new ExecutorCompletionService<Boolean>(  
                pool);  
        int destSize = 0;  
        for(IntWritable i : messages) {  
            exchangeResult.submit(blt.new Worker(i));  
            destSize++;  
        }  
          
        int count = 0;  
        while (count < destSize) {  
            Future<Boolean> f = exchangeResult.poll();  
            if (f == null)  
                continue;  
            count++ ;  
        }  
        try {  
            pool.awaitTermination(60, TimeUnit.SECONDS);  
        } catch (Throwable e) {  
            e.printStackTrace();  
        }  
        System.out.println("Last " + (System.currentTimeMillis() - start) + " ms");  
    }  
  
      class Worker implements  Callable<Boolean> {  
            IntWritable msg;  
  
            public Worker(IntWritable msg) {  
                this.msg = msg;  
            }  
              
            @Override  
            public Boolean call() throws Exception {  
                try {  
                     int sum = msg.get() ;  
                } catch (Exception e) {  
                    e.printStackTrace() ;  
                }  
                return true;  
            }  
        }  
      
//    class Worker implements  Runnable {  
//          IntWritable msg;  
//  
//          public Worker(IntWritable msg) {  
//              this.msg = msg;  
//          }  
//  
//          @Override  
//          public void run() {  
//              try {  
//                   int sum = msg.get() ;  
//              } catch (Exception e) {  
//                  e.printStackTrace() ;  
//              }  
//          }  
//      }  
        
}
第一种: Last 60186 ms 第二段代码: 

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.Callable;  
import java.util.concurrent.CompletionService;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ConcurrentLinkedQueue;  
import java.util.concurrent.ExecutorCompletionService;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
import java.util.concurrent.RejectedExecutionHandler;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
  
import org.apache.hadoop.io.IntWritable;  
  
public class ArrayTest {  
  
    public static void main(String[] args) {  
        long start = System.currentTimeMillis() ;  
        ArrayTest blt = new ArrayTest() ;  
        List<IntWritable> messages = new ArrayList<IntWritable>();  
          
        for(int i =0 ;i<10000; i++) {  
             messages.add(new IntWritable(i)) ;  
        }  
        RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();          
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors  
                .newCachedThreadPool();  
        executor.setMaximumPoolSize(64);  
        executor.setRejectedExecutionHandler(retryHandler);  
          
         for (IntWritable i : messages) {  
            executor.execute(blt.new Worker(i));  
          }  
  
          executor.shutdown();  
          try {  
            executor.awaitTermination(60, TimeUnit.SECONDS);  
          } catch (Exception e) {  
            e.printStackTrace() ;  
          }  
          
//      ExecutorService pool = Executors.newCachedThreadPool(); // 并发测试  
//      CompletionService<Boolean> exchangeResult = new ExecutorCompletionService<Boolean>(  
//              pool);  
//      int destSize = 0;  
//      for(IntWritable i : messages) {  
//          exchangeResult.submit(blt.new Worker(i));  
//          destSize++;  
//      }  
//        
//      int count = 0;  
//      while (count < destSize) {  
//          Future<Boolean> f = exchangeResult.poll();  
//          if (f == null)  
//              continue;  
//          count++ ;  
//      }  
//      try {  
//          pool.awaitTermination(60, TimeUnit.SECONDS);  
//      } catch (Throwable e) {  
//          e.printStackTrace();  
//      }  
        System.out.println("Last " + (System.currentTimeMillis() - start) + " ms");  
    }  
  
//    class Worker implements  Callable<Boolean> {  
//          IntWritable msg;  
//  
//          public Worker(IntWritable msg) {  
//              this.msg = msg;  
//          }  
//            
//          @Override  
//          public Boolean call() throws Exception {  
//              try {  
//                   int sum = msg.get() ;  
//              } catch (Exception e) {  
//                  e.printStackTrace() ;  
//              }  
//              return true;  
//          }  
//      }  
      
      class Worker implements  Runnable {  
            IntWritable msg;  
  
            public Worker(IntWritable msg) {  
                this.msg = msg;  
            }  
  
            @Override  
            public void run() {  
                try {  
                     int sum = msg.get() ;  
                } catch (Exception e) {  
                    e.printStackTrace() ;  
                }  
            }  
        }  
        
}  
  
class RetryRejectedExecutionHandler implements RejectedExecutionHandler {  
  
    @Override  
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {  
      try {  
        Thread.sleep(10);  
      } catch (InterruptedException e) {  
        e.printStackTrace() ;  
      }  
      executor.execute(r);  
    }  
}
Last 271 ms 可能是前一种写法有问题，导致性能很差，但是奇怪没有报错！第一种写法，即使用 Callable<Boolean>在线程数较少时(<100)，没有问题，但是线程数较大，如100,000,则会由于资源不足而阻塞，性能急剧降低。 第二种写法则不存在此问题。
rickylin86 2016-09-27
  • 打赏
  • 举报
 回复
引用 3 楼 cloudeagle_bupt 的回复:
[quote=引用 1 楼 inrtyx 的回复:] 为什么要关闭？
因为两个并行性过程是有依赖关系的，需要确保前面的过程结束后才能执行后面的啊[/quote] 如果你的需求是这样的话那么不需要关闭执行器啊.采用Executor.submit(Callable<>)然后通过Future来判断是否结束. 当Future.get方法得到结果后再放入新的任务到执行器中.然后调用Executor.shutdown()就可以了.
飞火流云 2016-09-26
  • 打赏
  • 举报
 回复
引用 1 楼 inrtyx 的回复:
为什么要关闭？
因为两个并行性过程是有依赖关系的，需要确保前面的过程结束后才能执行后面的啊
飞火流云 2016-09-26
  • 打赏
  • 举报
 回复
引用 楼主 cloudeagle_bupt 的回复:
在API没看到相关写法，求指点. 

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors
        .newCachedThreadPool();
    executor.setMaximumPoolSize(conf.getInt(DEFAULT_THREAD_POOL_SIZE, 64));
    executor.setRejectedExecutionHandler(retryHandler);

   executor.execute(new ComputeRunnable(XXX));
   executor.shutdown();
    try {
      executor.awaitTermination(60, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
      throw new IOException(e);
    }
这段代码执行完了，希望复用executor并执行下一个多线程计算，如何重启executor 呢? ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors .newCachedThreadPool(); 这样还要再写一遍? 以下是实例代码: 

package concurrencyTest;

import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class ExecutorReuse {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		 try {
			 long start = System.currentTimeMillis() ;
		 RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();
		 ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors
			        .newCachedThreadPool();
			    executor.setMaximumPoolSize(64);
			    executor.setRejectedExecutionHandler(retryHandler);
			    
	     int i = 0;
	     while (i<10000) {
	        executor.execute(new ComputeRunnable(i));
	        i++ ;
	     }
	     
	     executor.shutdown();
	     executor.awaitTermination(60, TimeUnit.SECONDS);
	     
             i=0 ;
	     while (i<100) {
		        executor.execute(new ComputeRunnable2(i));
		        i++ ;
		 }
	     executor.shutdown();
	     executor.awaitTermination(60, TimeUnit.SECONDS);
	     
	     System.out.println("Last " +( System.currentTimeMillis() - start ) +" ms");
	    } catch (Exception e) {
        e.printStackTrace() ;
     }
  }
}

class ComputeRunnable implements Runnable {
	int id = 0 ;
	
	public ComputeRunnable(int i ) {
		id = i ;
	}
	
	@Override
	public void run() {
           id =id *9 ;
//           System.out.println("ComputeRunnable1  started!");
	}
}

class ComputeRunnable2 implements Runnable {
	int id = 0 ;
	
	public ComputeRunnable2(int i ) {
		id = i ;
	}
	
	@Override
	public void run() {
           id =id *4 ;
           System.out.println("ComputeRunnable2  started!");
	}
}
结果报错！似乎只能这样写啊: 

package concurrencyTest;

import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class ExecutorReuse {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		 try {
			 long start = System.currentTimeMillis() ;
		 RejectedExecutionHandler retryHandler = new RetryRejectedExecutionHandler();
		 ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors
			        .newCachedThreadPool();
	    executor.setMaximumPoolSize(64);
	    executor.setRejectedExecutionHandler(retryHandler);
			    
	     int i = 0;
	     while (i<10000) {
	        executor.execute(new ComputeRunnable(i));
	        i++ ;
	     }
	     
	     executor.shutdown();
	     executor.awaitTermination(60, TimeUnit.SECONDS);
	     System.out.println("First 1 Step Last " +( System.currentTimeMillis() - start ) +" ms");
	     
	     start = System.currentTimeMillis() ;
	     executor = (ThreadPoolExecutor) Executors
			        .newCachedThreadPool();
	    executor.setMaximumPoolSize(64);
	    executor.setRejectedExecutionHandler(retryHandler);
         i = 0;	     
	     while (i<1000) {
	        executor.execute(new ComputeRunnable2(i));
	        i++ ;
		 }
	     executor.shutdown();
	     executor.awaitTermination(60, TimeUnit.SECONDS);
	     System.out.println("Last " +( System.currentTimeMillis() - start ) +" ms");

	    } catch (Exception e) {
        e.printStackTrace() ;
     }
  }
}

class ComputeRunnable implements Runnable {
	int id = 0 ;
	
	public ComputeRunnable(int i ) {
		id = i ;
	}
	
	@Override
	public void run() {
           id =id *9 ;
//           System.out.println("ComputeRunnable1  started!");
	}
}

class ComputeRunnable2 implements Runnable {
	int id = 0 ;
	
	public ComputeRunnable2(int i ) {
		id = i ;
	}
	
	@Override
	public void run() {
           id =id *4 ;
//           System.out.println("ComputeRunnable2  started!");
	}
}
不关闭如何确认前面的并行过程执行结束了呢?
inrtyx 2016-09-26
  • 打赏
  • 举报
 回复
为什么要关闭？
ThreadPoolExecutor复用流程的一点理解
ThreadPoolExecutor复用流程的一点理解 一、背景 ​ 最近在学并发编程的线程池，看了很多文章和视频，我认为都没有讲到线程池的核心。大家都说线程池能减少创建线程的消耗和销毁时间，但是却不解释是怎么做到的，而仅仅只是不断重复讲如果大于核心线程数会怎么样，大于最大线程数会这么样。。感觉本末倒置了。我觉得得研究一下，不然线程池在我眼里就是个多余的东西。 二、前提知识 ​ 这个可能只是我自己...
java threadpoolexecutor 返回值_Java ThreadPoolExecutor详解
ThreadPoolExecutor是Java语言对于线程池的实现。池化技术是一种复用资源，减少开销的技术。线程是操作系统的资源，线程的创建与调度由操作系统负责，线程的创建与调度都要耗费大量的资源，其中线程创建需要占用一定的内存，而线程的调度需要不断的切换线程上下文造成一定的开销。同时线程执行完毕之后就会被操作系统回收，这样在高并发情况下就会造成系统频繁创建线程。为此线程池技术为了解决上述问题，使...
Java ThreadPoolExecutor详解
ThreadPoolExecutor是Java语言对于线程池的实现。池化技术是一种复用资源，减少开销的技术。线程是操作系统的资源，线程的创建与调度由操作系统负责，线程的创建与调度都要耗费大量的资源，其中线程创建需要占用一定的内存，而线程的调度需要不断的切换线程上下文造成一定的开销。同时线程执行完毕之后就会被操作系统回收，这样在高并发情况下就会造成系统频繁创建线程。 为此线程池技术为了解决上述问题，使线程在使用完毕后不回收而是重复利用。如果线程能够复用，那么我们就可以使用固定数量的线程来解决并发问题，这样一来
深入解析Java ThreadPoolExecutor
ThreadPoolExecutor是Java语言对于线程池的实现。池化技术是一种复用资源，减少开销的技术。线程是操作系统的资源，线程的创建与调度由操作系统负责，线程的创建与调度都要耗费大量的资源，其中线程创建需要占用一定的内存，而线程的调度需要不断的切换线程上下文造成一定的开销。同时线程执行完毕之后就会被操作系统回收，这样在高并发情况下就会造成系统频繁创建线程。 为此线程池技术为了解决上述问题，使线程在使用完毕后不回收而是重复利用。如果线程能够复用，那么我们就可以使用固定数量的线程来解决并发问题，这样一来
Java SE

62,620

社区成员

307,251

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章