Java:线程池的七大参数及其工作原理

最新推荐文章于 2024-01-20 00:16:46 发布

Julian Q

最新推荐文章于 2024-01-20 00:16:46 发布

阅读量596

点赞数 2

分类专栏： # Android 面试移动端文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qjyws/article/details/123164989

版权

Android 同时被 3 个专栏收录

46 篇文章 3 订阅

订阅专栏

移动端

39 篇文章 0 订阅

订阅专栏

面试

33 篇文章 1 订阅

订阅专栏

文章目录

前言
一、池化技术
二、线程池
总结

前言

这篇博客记录笔者学习Java线程池的七大参数和工作原理的心路历程

一、池化技术

什么是池化技术？简单来说就是优化资源的使用，我准备好了一些资源，有人要用就到我这里拿，用完了就还给我。
在Java中比较池化技术有比较典型的代表就是一些类提供获取新对象的内部方法而不是利用new方法获取一个新对象，例如消息队列的Message对象获取新对象的方法便是Message.obtain()方法，但是实际上我们也可以通过new Message方法的方式获取一个Message对象，但是Java开发人员显然是希望我们使用前者获取新对象，因为使用obtain()方法内部维护了一个消息池，存放了一些Message,我们可以通过循环使用池中的Message对象避免大量创建新对象，从而避免内存抖动乃至内存溢出。

二、线程池

1.创建方式

而池化技术一个比较重要的的实现就是线程池。那么线程池用到了池化技术有什么好处呢？

降低资源的消耗
提高响应的速度
方便管理

而最重要的一点，便是线程复用、可以控制最大并发数、管理线程

Executors.newSingleThreadExecutor()

Executors.newSingleThreadExecutor()
这个线程池很有意思，说是线程池，但是池子里面只有一条线程。如果线程因为异常而停止，会自动新建一个线程补充。
我们可以测试一下：
我们对线程池执行十条打印任务，可以发现它们用的都是同一条线程

package com.qjy.javabasicpractice.threads;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void test02() {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        try {
            //对线程进行执行十条打印任务
            for(int i = 1; i <= 10; i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"=>执行完毕！");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //用完线程池一定要记得关闭
            threadPool.shutdown();
        }
    }
}

在这里插入图片描述

Executors.newFixedThreadPool(指定线程数量)

这个线程池是可以指定我们的线程池大小的，可以针对我们具体的业务和情况来分配大小。它是创建一个核心线程数跟最大线程数相同的线程池，因此池中的线程数量既不会增加也不会变少，如果有空闲线程任务就会被执行，如果没有就放入任务队列，等待空闲线程。

我们来测试一下：

package com.qjy.javabasicpractice.threads;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void test02() {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        try {
            //对线程进行执行十条打印任务
            for(int i = 1; i <= 10; i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"=>执行完毕！");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //用完线程池一定要记得关闭
            threadPool.shutdown();
        }
    }
}

在这里插入图片描述

可以看到置这里并不是所有线程都参与工作，但也是多条线程进行工作，说明有空闲线程任务就会被执行

Executors.newCachedThreadPool()

这个线程池是创建一个核心线程数为0，最大线程为Inter.MAX_VALUE的线程池，也就是说没有限制,线程池中的线程数量不确定，但如果有空闲线程可以复用，则优先使用，如果没有空闲线程，则创建新线程处理任务，处理完放入线程池。我们同样来测试一下

在以上代码中对线程池初始化代码进行修改

        ExecutorService threadPool = Executors.newCachedThreadPool();

最终结果如下
在这里插入图片描述
可以看到这里直接依次调用创建了10个线程

Executors.newScheduledThreadPool(指定最大线程数量)

创建一个没有最大线程数限制的可以定时执行线程池

2.核心源码

观察几大线程池实现的源码，不难发现其最终指向的创建线程池的核心都是以下的代码

    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

我们一般推荐，在平时使用线程池时尽量去使用ThreadPoolExcutor，对七大参数我们可以做以下的认知

corePoolSize: 线程池核心线程个数
workQueue: 用于保存等待执行任务的阻塞队列
maximunPoolSize: 线程池最大线程数量
ThreadFactory: 创建线程的工厂
RejectedExecutionHandler: 队列满，并且线程达到最大线程数量的时候，对新任务的处理策略
keeyAliveTime: 空闲线程存活时间
TimeUnit: 存活时间单位

关于线程池最大线程的数量，我们一般进行设计的思路如下：

CPU密集型，获得cpu的核数，不同的硬件不一样,设置核数的的线程数量。我们可以通过代码==Runtime.getRuntime().availableProcessors();==获取，然后设置。
IO密集型 IO非常消耗资源，所有我们需要计算大型的IO程序任务有多少个。一般来说，线程池最大值 > 大型任务的数量即可一般设置大型任务的数量*2

关于用银行货台样例理解这七大参数的作用可以查看这篇博客

线程池例1

3.为什么大部分线程池都用LinkedBlockingQueue?

LinkedBlockingQueue 使用单向链表实现，在声明LinkedBlockingQueue的时候，可以不指定队列长度，长度为Integer.MAX_VALUE, 并且新建了一个Node对象,Node对象具有item，next变量，item用于存储元素，next指向链表下一个Node对象，在刚开始的时候链表的head,last都指向该Node对象，item、next都为null,新元素放在链表的尾部，并从头部取元素。取元素的时候只是一些指针的变化，LinkedBlockingQueue给put(放入元素),take(取元素)都声明了一把锁，放入和取互不影响，效率更高。
ArrayBlockingQueue 使用数组实现，在声明的时候必须指定长度，如果长度太大，造成内存浪费，长度太小，并发性能不高，如果数组满了，就无法放入元素，除非有其他线程取出元素，放入和取出都使用同一把锁，因此存在竞争，效率比LinkedBlockingQueue低。