ThreadPoolExecutor的参数理解

一、使用Executors创建线程池    

        之前创建线程的时候都是用的Executors的newFixedThreadPool(),newSingleThreadExecutor(),newCachedThreadPool()这三个方法。

    1. newFixedThreadPool()

    创建线程数固定大小的线程池。

   2.newSingleThreadPool()

    创建线程数为1的线程池，

    3.newCachedThreadPool()

    创建可缓冲的线程池。没有大小限制

二、使用ThreadPoolExecutor创建线程池

ThreadPoolExecutor的构造函数

  public ThreadPoolExecutor(int corePoolSize,                                int maximumPoolSize,                                long keepAliveTime,                                TimeUnit unit,                                BlockingQueue<Runnable> workQueue,                                ThreadFactory threadFactory,                                RejectedExecutionHandler handler) {          if (corePoolSize < 0 ||              maximumPoolSize <= 0 ||              maximumPoolSize < corePoolSize ||              keepAliveTime < 0)              throw new IllegalArgumentException();          if (workQueue == null || threadFactory == null || handler == null)              throw new NullPointerException();          this.corePoolSize = corePoolSize;          this.maximumPoolSize = maximumPoolSize;          this.workQueue = workQueue;          this.keepAliveTime = unit.toNanos(keepAliveTime);          this.threadFactory = threadFactory;          this.handler = handler;      }

参数：

        1、corePoolSize核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnable

        2、maximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中

        3、keepAliveTime  保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。

        4、unit 时间单位

        5、workQueue 保存任务的阻塞队列

        6、threadFactory 创建线程的工厂

        7、handler 拒绝策略

任务执行顺序：

        1、当线程数小于corePoolSize时，创建线程执行任务。

        2、当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中

        3、线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize

        4、当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。

ThreadPoolExecutor默认有四个拒绝策略：

        1、ThreadPoolExecutor.AbortPolicy()   直接抛出异常RejectedExecutionException

        2、ThreadPoolExecutor.CallerRunsPolicy()    直接调用run方法并且阻塞执行

        3、ThreadPoolExecutor.DiscardPolicy()   直接丢弃后来的任务

        4、ThreadPoolExecutor.DiscardOldestPolicy()  丢弃在队列中队首的任务

当然可以自己继承RejectedExecutionHandler来写拒绝策略.

  int corePoolSize = 1;    int maximumPoolSize = 2;    int keepAliveTime = 10;  //  BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();    BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);    ThreadFactory threadFactory = Executors.defaultThreadFactory();    //线程池和队列满了之后的处理方式    //1.跑出异常    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();     RejectedExecutionHandler handler2 = new ThreadPoolExecutor.CallerRunsPolicy();    RejectedExecutionHandler handler3 = new ThreadPoolExecutor.DiscardPolicy();    RejectedExecutionHandler handler4 = new ThreadPoolExecutor.DiscardOldestPolicy();          ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, workQueue, threadFactory, handler2);            for (int j = 1; j < 15; j++) {     threadPoolExecutor.execute(new Runnable() {            public void run() {              try {        System.out.println(Thread.currentThread().getName());        TimeUnit.SECONDS.sleep(1);       } catch (InterruptedException e) {        e.printStackTrace();       }                    }     });    }        System.out.println(threadPoolExecutor);       }