深入理解线程池ThreadPoolExecutor - 问题整理

最新推荐文章于 2023-08-11 00:45:00 发布

cxmfzu

最新推荐文章于 2023-08-11 00:45:00 发布

阅读量480

点赞数

分类专栏：并发编程文章标签： java

本文链接：https://blog.csdn.net/cxmfzu/article/details/107610287

版权

并发编程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

execute 和 submit 区别和联系

很多博客都有提到线程池ThreadPoolExecutor 中提交任务的接口 execute和submit的区别。基本都是从返回值和异常的角度去看问题，但是我个人觉得没有讲到其本质区别，或者说讲的内容太浅，容易造成错误。首先submit类的接口源码位于ThreadPoolExecutor 的父类AbstractExecutorService中，源码如下：

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
   public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

从源码看出：

submit 相关接口，可以出入Callable或者Runnable的实例，返回值都是Future.
submit 相关接口，都是通过newTaskFor接口，转换为Runnable
submit 相关接口，都是调用execute实现任务的提交。

因此可以得到以下结论：

submit 实现了将Callable 或者 Runnable 封装为RunnableFuture类型的转换，由于RunnableFuture是继承了Runnable和Future的接口，具有获取返回值，抛出异常的接口，因此提交的任务才具有了这些接口。
submit 本质都是通过execute实现任务的提交。

在实现 ThreadPoolExecutor 优先级队列PriorityBlockingQueue示例如下：

    static class PriorityRunnable implements Runnable{
        private int priority;

        public PriorityRunnable(int priority) {
            this.priority = priority;
        }

        public int getPriority() {
            return priority;
        }

        public void setPriority(int priority) {
            this.priority = priority;
        }

        @Override
        public void run() {

        }
    }
    PriorityBlockingQueue priorityBlockingQueue = new PriorityBlockingQueue(16,
            new Comparator<PriorityRunnable>() {
        @Override
        public int compare(PriorityRunnable runnable1, PriorityRunnable runnable2) {
            return runnable1.getPriority() - runnable2.getPriority();
        }
    });
    public void test1(){
        // 创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 60,
                TimeUnit.SECONDS, priorityBlockingQueue);
        // 使用submit接口
        threadPoolExecutor.submit(new PriorityRunnable(5));
        threadPoolExecutor.submit(new PriorityRunnable(4));
        threadPoolExecutor.submit(new PriorityRunnable(3));
        threadPoolExecutor.submit(new PriorityRunnable(2));
    }

使用接口submit 会抛出异常

 java.lang.ClassCastException: java.util.concurrent.FutureTask cannot be cast to xxxx.$PriorityRunnable

本质原因是：ThreadPoolExecutor 的转换接口newTaskFor转换为FutureTask，在实现比较的时候无法转化为PriorityRunnable 的数据类型。
解决方案有两个;

不使用submit接口，使用execute 接口代替，保存存储在阻塞队列的数据是PriorityRunnable。
自定义ThreadPoolExecutor 和 FutureTask 队列。
方案一

		threadPoolExecutor.execute (new PriorityRunnable(5));
        threadPoolExecutor.execute (new PriorityRunnable(4));
        threadPoolExecutor.execute (new PriorityRunnable(3));
        threadPoolExecutor.execute (new PriorityRunnable(2));

方案二源码如下：

    static class PriorityRunnable implements Runnable{
        private int priority;

        public PriorityRunnable(int priority) {
            this.priority = priority;
        }

        public int getPriority() {
            return priority;
        }

        public void setPriority(int priority) {
            this.priority = priority;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000 * priority);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(priority);
        }
    }

    static class PriorityFutureTask extends FutureTask {
        private PriorityRunnable runnable;
        public PriorityFutureTask(PriorityRunnable runnable, Object result) {
            super(runnable, result);
            this.runnable = runnable;
        }
        public PriorityRunnable getRunnable() {
            return runnable;
        }
    }

    class PriorityThreadPoolExecutor extends ThreadPoolExecutor{

        public PriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        }

        public Future<?> submit(PriorityRunnable task) {
            if (task == null){
                throw new NullPointerException();
            }
            PriorityFutureTask ftask = new PriorityFutureTask(task,null);
            execute(ftask);
            return ftask;
        }
    }

    PriorityBlockingQueue priorityBlockingQueue = new PriorityBlockingQueue(16,
            new Comparator<PriorityFutureTask>() {
        @Override
        public int compare(PriorityFutureTask futureTask1, PriorityFutureTask futureTask2) {
            return futureTask1.getRunnable().getPriority() - futureTask2.getRunnable().getPriority();
        }
    });

    public void test1(){
        // 创建线程池
        PriorityThreadPoolExecutor threadPoolExecutor = new PriorityThreadPoolExecutor(1, 1, 60,
                TimeUnit.SECONDS, priorityBlockingQueue);
        // 使用submit接口
        threadPoolExecutor.submit(new PriorityRunnable(5));
        threadPoolExecutor.submit(new PriorityRunnable(4));
        threadPoolExecutor.submit(new PriorityRunnable(3));
        threadPoolExecutor.submit(new PriorityRunnable(2));
    }

两个方案的选择：

如果是不需要线程的执行结果，选择方案1.
如果需要线程的执行结果，尤其是Callable接口，或者需要抛出的异常，选择方案2。

如何停止线程池

关于如何优雅的停止线程池，网上的博客也写得非常清楚，这里就转载他们的结论：
使用shutdownNow方法，可能会引起报错，使用shutdown方法可能会导致线程关闭不了。

所以当我们使用shutdownNow方法关闭线程池时，一定要对任务里进行异常捕获。

当我们使用shuwdown方法关闭线程池时，一定要确保任务里不会有永久阻塞等待的逻辑，否则线程池就关闭不了。

最后，一定要记得，shutdownNow和shuwdown调用完，线程池并不是立马就关闭了，要想等待线程池关闭，还需调用awaitTermination方法来阻塞等待。

如何在任务里面捕获异常，我觉得可以新增一个方法，在方面里面判断线程的状态，如果现在状态是被中断的，就捕获改异常。检查线程的状态最好在使用到非本线程的资源的时候检查一下。示例代码如下

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            try {
            	// 在使用非本线程资源的时候，检查一下
                checkInterrupted();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        private void checkInterrupted() throws InterruptedException {
            if (Thread.currentThread().isInterrupted()){
                throw new InterruptedException();
            }
        }
    }

在Callable中的实例

static class MyCallable implements Callable<String>{

        @Override
        public String call() throws Exception {
            checkInterrupted();
            return null;
        }
        private void checkInterrupted() throws InterruptedException {
            if (Thread.currentThread().isInterrupted()){
                throw new InterruptedException();
            }
        }
    }

关闭和移除指定线程或者任务

在android开发过程有可能会有下面的场景需求：在某个界面需要执行异步任务，将异步任务提交到线程池中，但是在任务尚未完成的过程中，需要退出这个界面，如果关闭线程池肯定可以想办法将所有的工作线程退出，但是这样重新进入这个界面又需要重新创建线程池，或者这个线程池里面有其他的工作线程是不能退出的，这时候就需要在阻塞队列中删除指定的任务和工作线程执行的指定线程。
这个需求使用原生的接口，是不能实现的，需要自定义ThreadPoolExecutor来实现。
移除指定任务和关闭指定线程的接口

	/**
	缺点：
	1. 入参只能是Runnable，无法在阻塞队列中移除提交的Callable
	2. tryTerminate 只是关闭空闲的工作线程，不能关闭指定的线程
	**/
    public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }
	/**
	缺点：
	1. 无入参，只能遍历移除可以cancel的任务
	2. tryTerminate 只是关闭空闲的工作线程，不能关闭指定的线程
	**/
    public void purge() {
        final BlockingQueue<Runnable> q = workQueue;
        try {
            Iterator<Runnable> it = q.iterator();
            while (it.hasNext()) {
                Runnable r = it.next();
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    it.remove();
            }
        } catch (ConcurrentModificationException fallThrough) {
            for (Object r : q.toArray())
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    q.remove(r);
        }

        tryTerminate(); // In case SHUTDOWN and now empty
    }

针对在阻塞队列中移除指定task,停止工作线程中指定task的需求，需要自定义线程池，下面简要的写一个小实例，用于满足这样的需求。

    static public class FlexibleThreadPoolExecutor extends ThreadPoolExecutor {
        /**
         * 用于存储Callable 和 FutureTask 的对应关系,是 workQueue 的一部分
         */
        private ArrayMap<FutureTask, Callable> callableMap = new ArrayMap<>();
        /**
         * 提交给工作线程运行的Runnable,beforeExecute,afterExecute 线程安全
         */
        private ArrayMap<Runnable,Thread> workRunnable = new ArrayMap<>();

        public FlexibleThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        }

        public FlexibleThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
        }

        public FlexibleThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
        }

        public FlexibleThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        }

        @Override
        public Future<?> submit(Runnable task) {
            return super.submit(task);
        }

        @Override
        public void execute(Runnable command) {
            System.out.println("execute = "+command.toString());
            super.execute(command);
        }

        /**
         * @param callable
         * @param <T>
         * @return
         */
        @Override
        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
            System.out.println("newTaskFor callable = "+callable.toString());
            FutureTask<T> futureTask =  new FutureTask<T>(callable);
            if (!isShutdown() && !isTerminating() && !isTerminating()){
                // 在线程池是RUNNING 状态，添加到map中。
                callableMap.put(futureTask,callable);
            }
            System.out.println("newTaskFor futureTask = "+futureTask.toString());
            return futureTask;
        }

        @Override
        protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
            System.out.println("newTaskFor runnable = "+runnable.toString());
            RunnableFuture<T> runnableFuture = super.newTaskFor(runnable, value);
            System.out.println("newTaskFor runnableFuture = "+runnableFuture.toString());
            return runnableFuture;
        }

        @Override
        protected void beforeExecute(Thread t, Runnable r) {
            System.out.println("beforeExecute thread = "+t.toString()+",r = "+r.toString());
            workRunnable.put(r,t);
        }

        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            if (r instanceof FutureTask){
                System.out.println("afterExecute FutureTask ,r = "+r.toString());
                // 有可能会移除失败
                Callable callable = callableMap.remove(r);
                System.out.println("afterExecute callable = "+callable);
            }
            System.out.println("afterExecute r = "+r);

            workRunnable.remove(r);
        }

        @Override
        public boolean remove(Runnable task) {
            Thread workThread = workRunnable.get(task);
            if (workThread!= null){
                workThread.interrupt();
            }
            return super.remove(task);
        }

        public  <T> boolean remove(Callable<T> task){
            if (task == null){
                throw new NullPointerException();
            }
            FutureTask futureTask = null;
            Set<Map.Entry<FutureTask, Callable>> set =  callableMap.entrySet();
            for (Map.Entry<FutureTask, Callable> entry : set){
                if (entry.getValue() .equals(task)){
                    futureTask = entry.getKey();
                    break;
                }
            }
            if (futureTask != null){
                callableMap.remove(futureTask);
            }
            return remove(futureTask);
        }

        @Override
        public List<Runnable> shutdownNow() {
            callableMap.clear();
            return super.shutdownNow();
        }

    }

线程池核心线程数据如何设置

关于如何设置核心工作线程数，没有一个定量标准，可以参考美团博客，知乎的文档
参考链接：
https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html
https://www.zhihu.com/question/37804956?sort=created