thread_ThreadPoolExecutor

目录

1.基础知识

2.简单应用

3.异常机制

4.丰富的扩展

一.基础知识

构造函数。

public　ThreadPoolExecutor( 　　
int　corePoolSize, 　　 指的是保留的线程池大小
int　maximumPoolSize, 　　 指的是线程池的最大大小
long　keepAliveTime, 　　 指的是空闲线程结束的超时时间
TimeUnit　unit, 　　
BlockingQueue<Runnable>　workQueue) 　表示存放任务的队列 　

工作过程：

1 、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2 、当调用 execute() 方法添加一个任务时，线程池会做如下判断：
  a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
  b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
  c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
  d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
3 、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4 、当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

二.简单应用

    public void threadPool1Test() throws InterruptedException {
       BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
       ThreadPoolExecutor exe = new ThreadPoolExecutor(2, 6, 1, TimeUnit.DAYS, queue);
        try {
            int threadNum = 0;
            for (int i = 0; i < 10; i++) {
                threadNum++;
                final int currentThreadNum = threadNum;
                exe.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println("子线程[" + currentThreadNum + "]开启");
                            Thread.sleep(1000 * 10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            System.out.println("子线程[" + currentThreadNum + "]结束");
                        }
                    }
                });
            }

            //不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
            System.out.println("已经开启所有的子线程");
            exe.shutdown();
            System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");

            //判断线程池所有任务是否执行完毕
            while (true) {
                if (exe.isTerminated()) {
                    System.out.println("所有的子线程都结束了！");
                    break;
                }
                Thread.sleep(1000);
                System.out.println("线程池中线程数目："+exe.getPoolSize()+
                                   "，队列中等待执行的任务数目："+ exe.getQueue().size()+
                                   "，已执行玩别的任务数目："+exe.getCompletedTaskCount());
                System.out.println("线程队列大小为-->"+queue.size());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("主线程结束");
        }
    }

1、BlockingQueue 只是一个接口，常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话，因为队列不会满，所以 execute() 不会抛出异常，而线程池中运行的线程数也永远不会超过 corePoolSize 个，keepAliveTime 参数也就没有意义了。
2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后，主线程就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法，那么线程池会一直保持下去，以便随时添加新的任务。

二.异常处理

线程超出了线程池的总容量（线程队列大小+最大线程数）

    @Test
    public void threadPool2Test() throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 6, 1, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(4));
        //executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        executor.setRejectedExecutionHandler(
          new RejectedExecutionHandler() {
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println(String.format("Task %d rejected.", r.hashCode()));
                //System.out.println("DemoTask Rejected : " + ((DemoThread) r).getName());
                System.out.println("Waiting for a second !!");
                try {
                    Thread.sleep(1000);
                     executor.execute(r);
                     //executor.getQueue().put(r);
                } catch (InterruptedException e) {
                }
            }
          });
        ///////
        for (int i = 0; i < 11; i++) {
            final int taskNum = i;
            Runnable myTask = new Runnable() {
                @Override
                public void run() {
                    System.out.println("正在执行task " + taskNum);

                    try {
                        Thread.currentThread().sleep(100 * (new Random()).nextInt(8));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("task " + taskNum + "执行完毕");
                }
            };
            executor.execute(myTask);
        }
        // 不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
        executor.shutdown();
        while (true) {
            if (executor.isTerminated()) {
                System.out.println("所有的子线程都结束了！");
                break;
            }
            Thread.sleep(1000);
            System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" + executor.getQueue().size()
                    + "，已执行玩别的任务数目：" + executor.getCompletedTaskCount());
        }
    }

ThreadPoolExecutor 提供 4 个现有的策略，分别是：

ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常

ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作
ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务
ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。
使用CallerRunsPolicy，会将所有线程都执行到，也不可避免的会使用主线程来加载一个线程任务。一次同时创建maximumPoolSize个线程，加上主线程，就是一次执行maximumPoolSize+1个线程任务，等执行完后才会，再执行maximunPoolSize+1个线程任务，当然创建的maximumPoolSize个线程也会复用。
显然这种策略保证了每一个线程任务都会执行，但牺牲了性能。而，DiscardPolicy和DiscardOldestPolicy都会抛弃容纳不了的线程任务，保证了性能。

a. ThreadPoolExecutor可以设置一个“拒绝策略”，这是指当一个task被拒绝添加到线程池中时，采取的处理措施，
　　executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
 b.task非常重要，“等得起”，但是“丢不起”
    System.out.println("Waiting for a second !!");
   try {
      Thread.sleep(1000);
       executor.execute(r);
   } catch (InterruptedException e) {
   }
 c.利用RejectedExecutionHandler来阻塞submit()？
    首先 submit()方法是调用了workQueue的offer()方法来塞入task，而offer()方法是非阻塞的，当workQueue已经满的时候，offer()方法会立即返回false，并不会阻塞在那里等待workQueue有空出位置，所以要让submit()阻塞，关键在于改变向workQueue添加task的行为，
  if (!executor.isShutdown()) {
      try {
          executor.getQueue().put(r);
       } catch (InterruptedException e) {
       }
   }
   调用了getQueue()方法，得到了workQueue，再调用其put()方法，将task放到workQueue中，而这个put()方法是阻塞的
   当workQueue满时，submit()一个task会导致调用我们自定义的RejectedExecutionHandler，而我们自定义的RejectedExecutionHandler会保证该task继续被尝试   用阻塞式的put()到workQueue中。

d.重写了offer()方法的BlockingQueue

由于submit()是调用workQueue的offer()方法来添加task的，而offer()是非阻塞的，所以，如果我们自己实现一个BlockingQueue，其offer()方法是阻塞的

public class LimitedQueue<E> extends LinkedBlockingQueue<E> {
　　public LimitedQueue(int maxSize) {
　　　　super(maxSize);
　　}
　　@Override
　　public boolean offer(E e) {
　　　　// turn offer() and add() into a blocking calls (unless interrupted)
　　　　try {
　　　　　　put(e);
　　　　　　return true;
　　　　} catch (InterruptedException ie) {
　　　　　　Thread.currentThread().interrupt();
　　　　}
　　　　return false;
　　}
}

四.丰富的可扩展性

1.扩展生成器，如线程的创建前beforeExecute，创建后afterExecute，退出terminated；   
                         线程的创建策略， 通过重构ThreadFactory 重构线程名，设置守护线程等；

线程的拒绝策略，日志，拒绝，重试等

线程运行抛出异常机制

class ExtThreadPoolExecutor extends ThreadPoolExecutor {

    public ExtThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        super.setThreadFactory(new ExtThreadFactory());
        super.setRejectedExecutionHandler(new ExtRejectedExecutionHandler());
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        System.out.println("Perform beforeExecute() ");
    }
    @Override
    protected void terminated() {

        System.out.println("线程池退出 ");
    }
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t != null) {
            System.out.println("Perform exception handler logic");
        }
        System.out.println("Perform afterExecute() ");
    }
    /////////////////////////////////
//    @Override
//    public void execute(Runnable task) {
//        super.execute(wrap(task,clientTrace(),Thread.currentThread().getName()));
//    }
//    @Override
//    public Future<?> submit(Runnable task) {
//        return super.submit(wrap(task,clientTrace(),Thread.currentThread().getName()));
//    }
    private Exception clientTrace(){
        return new Exception("client stack trace");
    }
    private Runnable wrap(final Runnable task ,final Exception clientStack,String clientThreadName ){
        return new Runnable(){
            @Override
            public void run() {
                try {
                    task.run();
                } catch (Exception e) {
                    clientStack.printStackTrace();
                    throw e;
                }
                task.run();

            }
        };

    }
    ///////////////////////////////////////////
    private class ExtThreadFactory implements ThreadFactory {
        private AtomicInteger count = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            String threadName = ExtThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);
            System.out.println("create "+threadName);
            //t.setDaemon(true);
            t.setName(threadName);
            return t;
        }
    }

    //
    private class ExtRejectedExecutionHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println("DemoTask Rejected : " + ((DemoThread) r).getName());
            System.out.println("Waiting for a second !!");

            if (!executor.isShutdown()) {
                try {
                    Thread.sleep(1000);
                    // executor.execute(r);
                     executor.getQueue().put(r);
                    // 当task被拒绝添加到线程池中时，ThreadPoolExecutor会采用“丢弃”策略来对待这个任务，即这个task被丢弃了。
                //    System.out.println("Lets add another time : " + ((DemoThread) r).getName());
                } catch (InterruptedException e) {
                }
            }
        }
    }
}

2.扩展生成器

class DemoThread implements Runnable {
    private String name = null;

    public DemoThread(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Executing : taskname: " + name +", Thread id: " +Thread.currentThread().getId());
    }
}

    public static void main(String[] args) {

        BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(50);

        ExtThreadPoolExecutor pool = new ExtThreadPoolExecutor(10, 20, 5000, TimeUnit.MILLISECONDS,
                blockingQueue);

        for (int i = 1; i < 100; i++) {
            System.out.println("提交第" + i + "个任务!");
            pool.execute(new DemoThread(Integer.valueOf(i).toString() ) );
            pool.submit(new DemoThread(Integer.valueOf(i).toString() ));
        }

        // 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了
        // exec.destory();

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }