ThreadPoolExecutor创建线程池

  

   

    

     

    
    

     
    
      /**
     
    
   

    

     

    
    

     

       * public ThreadPoolExecutor(int corePoolSize,
     
    
   

    

     

    
    

     

       * int maximumPoolSize,
     
    
   

    

     

    
    

     

       * long keepAliveTime,
     
    
   

    

     

    
    

     

       * TimeUnit unit,
     
    
   

    

     

    
    

     

       * BlockingQueue<Runnable> workQueue,
     
    
   

    

     

    
    

     

       * RejectedExecutionHandler handler) {
     
    
   

    

     

    
    

     

       * this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
     
    
   

    

     

    
    

     

       * Executors.defaultThreadFactory(), handler);
     
    
   

    

     

    
    

     

       * }
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
   
      /**参数解释：
     
    
   

    

     

    
    

     

       *corePoolSize 线程池核心池的大小
     
    
   

    

     

    
    

     

       *maximumPoolSize 线程池的最大线程数
     
    
   

    

     

    
    

     

       *keepAliveTime 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间
     
    
   

    

     

    
    

     

       *unit keepAliveTime 的时间单位
     
    
   

    

     

    
    

     

       *workQueue 用来储存等待执行任务的队列
     
    
   

    

     

    
    

     

       *ThreadFactory 线程工程（可自建或使用默认）
     
    
   

    

     

    
    

     

       *handler 拒绝策略
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
    
      public 
      static 
      int corePoolSize=
      1;
     
    
   

    

     

    
    

     
    
      public 
      static 
      int maximumPoolSize=
      10;
     
    
   

    

     

    
    

     
    
      public 
      static Long keepAliveTime=
      100L;
     
    
   

    

     

    
    

     
    
      public 
      static TimeUnit unit=TimeUnit.SECONDS;  
     
    
   

    

     

    
    

     
  
     
    
   

    

     

    
    

     
    
      public static void main(String[] args) {
     
    
   

    

     

    
    

     

              ThreadPoolExecutor threadPoolExecutor=
      new ThreadPoolExecutor(
     
    
   

    

     

    
    

     

                      corePoolSize,
     
    
   

    

     

    
    

     

                      maximumPoolSize,
     
    
   

    

     

    
    

     

                      keepAliveTime,
     
    
   

    

     

    
    

     

                      unit,
     
    
   

    

     

    
    

     
                
      new ArrayBlockingQueue<>(
      100),
     
    
   

    

     

    
    

     
                
      new ThreadPoolExecutor.DiscardOldestPolicy());
     
    
   

    

     

    
    

     
        
      for (
      int i=
      0;i<
      5;i++){
     
    
   

    

     

    
    

     

                  threadPoolExecutor.execute(()->{
     
    
   

    

     

    
    

     
                
      try {
     
    
   

    

     

    
    

     

                          System.out.println(
      "线程启动");
     
    
   

    

     

    
    

     

                          Thread.sleep(
      5*
      1000);
     
    
   

    

     

    
    

     

                      } 
      catch (InterruptedException e) {
     
    
   

    

     

    
    

     

                          e.printStackTrace();
     
    
   

    

     

    
    

     

                      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

                  });
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              threadPoolExecutor.shutdown();
      // 关闭线程池
     
    
   

    

     

    
    

     

          }
     
    
  

拒绝策略： 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务
ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务
线程池的默认拒绝策略为AbortPolicy，即丢弃任务并抛出RejectedExecutionException异常

使用线程池和不使用线程的区别：差异在于使用线程池的方式是复用线程。 不使用线程池的方式是每次都要创建线程所以消耗的时间差距大，因为执行的工作比较简单所以大部分时间用来创建线程。

核心线程数的设置：
    Nthreads=Ncpu*Ucpu*(1+w/c)，其中
    Ncpu=CPU核心数
    Ucpu=cpu使用率，0~1
    W/C=等待时间与计算时间的比率
    IO密集型设置核心线程数= 2Ncpu
    计算密集型设置核心线程数=Ncpu
    计算密集型任务的特点：要进行大量的计算，消耗CPU资源
    IO密集型任务特点：涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成，IO的速度远远低于CPU和内存的速度。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用 。