《Java并发编程的艺术》第九章 Java中的线程池

最新推荐文章于 2022-11-12 18:04:09 发布

KirutoCode

最新推荐文章于 2022-11-12 18:04:09 发布

阅读量252

点赞数

分类专栏： Java开发原理

本文链接：https://blog.csdn.net/McEason/article/details/108726386

版权

Java开发原理专栏收录该内容

13 篇文章 1 订阅

订阅专栏

文章目录

第九章 Java中的线程池

第九章 Java中的线程池

使用线程池的好处：

降低资源消耗：降低线程创建和销毁造成的消耗。
提高响应速度：任务来时，不需要等到线程创建就能立即执行。（因为已有线程？还是因为任务队列）
提高线程的可管理性：使用线程池可以进行统一分配、调优和监控。

框架图

高清图片地址

线程池的实现原理

提交一个新任务到线程池时，线程池的处理流程：
（核心与普通线程池如何区分，为何区分，为了队列而分？）

判断核心线程池里的线程是否都在执行任务，不是就创建，是就下一步。
判断工作队列是否已满，没满就把该任务存储在工作队列中，满了就下一步。
判断线程池的线程是否都处于工作状态，不是就创建，是就交给饱和策略。

流程图：

ThreadPoolExecutor执行示意图：

注意：第一步和第三步创建线程都需要获取全局锁
设计目的：为了在执行execute()方法的时候，尽可能避免获取全局锁，ThreadPoolExecutor完成预热之后（当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法都调用执行步骤2，而步骤2不需要获取全局锁。

源码分析：

工作线程：

运行：线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列里的人物来执行。
代码：

ThreadPoolExecutor执行任务示意图：

在execute()方法中创建一个线程时，会让这个线程执行当前任务
这个线程执行完上图1中的任务后，会反复从BlockingQueue获取任务来执行

线程池的使用

线程池的创建

创建代码：

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds, runnableTaskQueue, threadFactory, handler);

参数说明：

corePoolSize：线程池基本大小。有新来的任务就创建线程执行，任务数大于这个数就不创建了，可以调用线程池的prestartAllCoreThreads()方法来提起创建并启动所有基本线程。
runnableTaskQueue：任务队列。用于保存等待执行的任务的阻塞队列，可选的有ArrayBlockingQueue、LinkedBlockingQueue（Executors.newFixedThreadPool()在用这个）、SynchronousQueue（Executors.newCachedThreadPool在用这个）、PriorityBlockingQueue。
maxmumPoolSize：线程池允许创建的最大线程数。队列满了再用这个，如果用的是无界的任务队列这个参数就没什么效果。
keepAliveTime：线程活动保持时间。线程池的工作线程空闲后，停一会再关闭。适合任务多、每次执行时间短的任务，提高效率。
TimeUnit：线程活动保持时间的单位。DAYS、HOURS、MINUTES、MILLISECONDS、MICROSECONDS、NANOSECONDS。
ThreadFactory：用于设置创建线程的工厂，可以通过给每个线程起名字：new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();
RejectedExecutionHandler：饱和策略。当队列和线程池都满了的时候，采取的方法。
- AbortPolicy：直接抛出异常。（默认）
- CallerRunsPolicy：直接在调用者所在线程来运行任务。（这样调用者自身的性能可能急剧下降）
- DiscardOldestPolicy：丢弃掉队列头的任务，并执行当前任务。
- DiscardPolicy：不处理，丢弃。

向线程池提交任务

两个方法

execute()：提交不需要返回值的任务，无法判断是否被线程池执行成功。
submit()：提交需要返回值的任务，会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功。可以通过future的get()方法来获取返回值，如果没有执行完成，get()会造成调用get()的线程的阻塞。使用get(long timeout, TimeUnit unit)方法会阻塞一段事件后立即返回，此时有可能完成不了。

Future类型：
未来表示异步计算的结果。提供的方法用于检查计算是否完成、等待计算完成以及检索计算结果。结果只能在计算完成后使用get方法检索，必要时可以阻塞，直到准备好为止。取消由cancel方法执行。还提供了其他方法来确定任务是正常完成还是被取消。一旦计算完成，就不能取消计算。如果为了可取消性而使用Future，但不提供可用的结果，可以声明形式Future<?>，并作为基础任务的结果返回null。

代码比较：

不使用get方法

public class tt {
    private static final AbortPolicy abortPolicy = new AbortPolicy();
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 3, TimeUnit.MILLISECONDS, workQueue);


        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Execute开始");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Execute结束");
            }
        });
        Future<?> submit = poolExecutor.submit(new Runnable() {

            @Override
            public void run() {
                System.out.println("Submit开始");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Submit结束");
            }
        });

        // System.out.println("get: " + submit.get());
        System.out.println("任务数: " + poolExecutor.getTaskCount());
        System.out.println("完成任务数：" + poolExecutor.getCompletedTaskCount());

    }
}

输出结果：
可以看到先把tt线程走完了，然后两个自定义线程才运行完。

Execute开始
Submit开始
任务数: 2
完成任务数：0
Execute结束
Submit结束

使用get方法

public class tt {
    private static final AbortPolicy abortPolicy = new AbortPolicy();
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 3, TimeUnit.MILLISECONDS, workQueue);


        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Execute开始");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Execute结束");
            }
        });
        Future<?> submit = poolExecutor.submit(new Runnable() {

            @Override
            public void run() {
                System.out.println("Submit开始");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Submit结束");
            }
        });

        System.out.println("get: " + submit.get());
        System.out.println("任务数: " + poolExecutor.getTaskCount());
        System.out.println("完成任务数：" + poolExecutor.getCompletedTaskCount());
    }
}

输出结果：
可见是在get出停顿了一会，以待任务完成，然后才继续tt线程。

Execute开始
Submit开始
Execute结束
Submit结束
get: null
任务数: 2
完成任务数：2

关闭线程池

原理：遍历线程池中的工作线程，然后逐个调用线程的interrupt方法中断线程，所以无法响应中的任务可能永远无法终止。

方法	流程	使用场景
shutdownNow	将线程池状态设置成STOP，然后尝试停止所有正在执行或暂停任务的线程，并返回等待执行任务的列表	如果不一定要执行完，用这个
shutdown	将线程池的状态设置成SHUTDOWN状态，终端所有没有正在执行任务的线程	一般用这个

（所以说shutdown还会等一等，正在执行的不中断，而shutdownNow立马中断）。

配置线程池

一些分配建议：

CPU密集型任务：配置尽可能小的线程，入配置 $N_{cpu}+1$ 个线程的线程池。
IO密集型任务：并不是一直执行在任务，应配置尽可能多的线程，如 $\times N_{cpu}$ 。（为啥要多？读写耗时长？）
混合型任务：可以拆分，如果两个任务执行时间相差不大，分解后执行的吞吐量会高于串行；如果执行时间相差太大，就没必要分解。
Runtime.getRuntime().availableProcessors()：可以获得当前设备的CPU个数。
执行时间不同的任务：可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的先执行。
依赖数据库连接池的任务：等待时间越长，则CPU空闲时间越长，那么线程数就应设置的越大，才能更好的利用CPU。（分散开，免得一个线程在等线程还有大量空间没用？）
建议使用有界队列：有界队列能增加系统的稳定性和预警能力，可以根据需要设大一点，比如几千。

线程池的监控

一些监控方法：

taskCount：线程池需要执行的任务数量。
completedTaskCount：线程池在运行过程中已完成的任务数量。
largestPoolSize：线程池层创建过的最大线程数量，可以通过这个知道是否满过。
getPoolSize：线程池的线程数，如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。（？不还有个停止参数吗？好像关闭和销毁鄙视一回事？）
getActiveCount：获取活动的线程数。

挂钩子：
通过继承线程池来自定义线程，重写beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。

public class PoolMy extends ThreadPoolExecutor {
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        System.out.println("我要开始了");
        super.beforeExecute(t, r);
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        System.out.println("我好了");
        super.afterExecute(r, t);
    }

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

    @Override
    protected void terminated() {
        System.out.println("关闭");
        super.terminated();
    }
}

测试代码：

public void test(){
    BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);
    PoolMy poolExecutor = new PoolMy(5, 10, 3, TimeUnit.MILLISECONDS, workQueue);

    poolExecutor.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("Are you ok?");
        }
    });

    poolExecutor.shutdown();
}

输出结果：

我要开始了
Are you ok?
我好了
关闭