java基础 Excutor

1. Excutor是java自带的一个多线程框架，使用这个框架 可以让程序员无管理线程的具体生命周期。

2. /**
    * 测试类，重复了一百次添加新线程
    */
   public class ExcutorTest {
       public static void main(String[] args)  throws InterruptedException{
           Server  server = new Server();
           for(int i = 0; i < 100; i++){
               Task task = new Task("Task" + i);
               Thread.sleep(10);
               server.submitTask(task);
           }
           server.endServer();
       }
   }
   

   import java.util.concurrent.Executors;
   import java.util.concurrent.ThreadPoolExecutor;
   
   /**
    * 线程池类，定义了一个ThreadPoolExecutor，submitTask方法输出了在 执行一个新线程
    * 时候线程池的信息，和开启一个新线程
    */
   public class Server {
       private ThreadPoolExecutor executor;
   
       public Server() {
           executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
       }
       public void submitTask(Task task){
           System.out.println("server : A new task has arrived");
           executor.execute(task);
           System.out.println("server : Pool size :  "+ executor.getPoolSize());
           System.out.println("server : active count" + executor.getActiveCount());
           System.out.println("server : completed tasks : " + executor.getCompletedTaskCount());
       }
   
   
       public void endServer(){
           executor.shutdown();
       }
   }
   

   /**
    * 模拟任务，实现了Runnable接口，在具体的run方法中就是随机睡眠一段时间和输出构造方法传进来的参数
    */
   public class Task  implements  Runnable{
       private String name;
       public Task(String name){
           this.name = name;
       }
   
       @Override
       public void run(){
           try{
               Long duration = (long)(Math.random() * 1000);
               System.out.println("    name is " + name);
               Thread.sleep(duration);
           }catch (InterruptedException e){
               e.printStackTrace();
           }
   
       }
   }
   

   例子2

   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.Executors;
   import java.util.concurrent.Future;
   import java.util.concurrent.ThreadPoolExecutor;
   
   public class SumTest {
       public static void main(String[] args) {
   //        定义一个线程池对象
           ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(4);
   //        Future为线程的返回值，这里泛型指定为Integer
           List<Future<Integer>> resultList = new ArrayList<>();
   //        SumTask方法将参数传进去之后子线程就开始执行，程序员无需具体去管理了
           for(int i=0; i<10;i++){
               SumTask calculator  = new SumTask(i*100 +1, (i+1) * 100);
               Future<Integer> result = executor.submit(calculator);
               resultList.add(result);
           }
   //        这里是每间隔五十毫秒进行一次轮询，直到所有线程都执行完毕
           do{
               System.out.println("main : 已经完成了多少"+executor.getCompletedTaskCount()+"个任务");
               for(int i=0;i<resultList.size();i++){
                   Future<Integer> result = resultList.get(i);
                   System.out.println("main task :" + i + result.isDone());
               }
               try{
                   Thread.sleep(50);
               }catch (InterruptedException e){
                   e.printStackTrace();
               }
           }while (executor.getCompletedTaskCount() < resultList.size());
   //        这里就是对所有子线程执行的结果进行累加
           int total = 0;
           for(int i=0;i < resultList.size(); ++i){
               Future<Integer> result = resultList.get(i);
               Integer sum = null;
               try{
                   sum = result.get();
                   total = total + sum;
               }catch (InterruptedException e){
                   e.printStackTrace();
               }catch (ExecutionException e){
                   e.printStackTrace();
               }
           }
           System.out.println("1 - 1000的总和是" + total);
       }
   }
   

   import java.util.Random;
   import java.util.concurrent.Callable;
   
   /**
    * 实现了Callable接口的类，可以使用call方法执行子线程，执行单个子线程的时候
    * 就是串行执行的
    */
   public class SumTask  implements Callable<Integer> {
       private int startNumber;
       private int endNumber;
       public SumTask(int startNumber, int endNumber){
           this.startNumber  = startNumber;
           this.endNumber = endNumber;
       }
       @Override
       public Integer call() throws Exception{
           int sum = 0;
           for(int i = startNumber; i< endNumber; i++){
               sum += i;
           }
           Thread.sleep(new Random().nextInt(1000));
           System.out.println(Thread.currentThread().getName() + "," + sum);
           return sum;
       }
   }