java自带线程池了解

不断学习，不断总结，总有一天我会变的很强，大家如果觉的文章有欠缺的地方，还请不吝赐教，技术学习在于就是不断试错的过程，加油！！！

一、四种线程池

Java通过Executors提供四种线程池，分别为

1、newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
2、newFixedThreadPool  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3、newScheduledThreadPool 创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行。 
4、newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 

二、核心类

四种线程池本质都是创建ThreadPoolExecutor类，ThreadPoolExecutor构造参数如下

1、int corePoolSize, 核心线程大小

2、int maximumPoolSize,最大线程大小

3、long keepAliveTime, 超过corePoolSize的线程多久不活动被销毁时间

4、TimeUnit unit,时间单位

5、BlockingQueue<Runnable> workQueue 任务队列

6、ThreadFactory threadFactory 线程池工厂

7、RejectedExecutionHandler handler 拒绝策略

三、阻塞队列

1、ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列

2、LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列（常用）

3、PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列

4、DelayQueue： 一个使用优先级队列实现的无界阻塞队列

5、SynchronousQueue： 一个不存储元素的阻塞队列（常用）

6、LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列

7、LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列

四、线程池任务执行流程

1、当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。

2、当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行

3、当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务

4、当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理

5、当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，释放空闲线程

6、当设置allowCoreThreadTimeOut(true)时，该参数默认false，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

五、练习代码

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

/**
 * @author Denny
 * @date 2022/3/21 16:26
 */
public class ThreadPoolTest {

    /**
     * newSingleThreadExecutor 创建一个单线程化的线程池，
     * 它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序
     * (FIFO, LIFO, 优先级)执行
     */
    public static void testNewSinglethreadExecutor(){

        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i=0;i<10;i++){
            int finalI = i;
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+finalI);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

    }

    /**
     * newFixedThreadPool  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    public static void testNewFixedThreadPool(){
        //设置最大线程数和核心线程数
        int max_core = 3;
        ExecutorService executorService = Executors.newFixedThreadPool(max_core);

        for (int i = 0; i < 10 ; i++) {
            int finalI = i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+ finalI);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    /**
     * newScheduledThreadPool 创建一个可定期或者延时执行任务的定长线程池，
     * 支持定时及周期性任务执行。
     */
    public static void testNewScheduledThreadPool(){
        int coreNum = 3;
        ExecutorService executorService = Executors.newScheduledThreadPool(coreNum);
        for (int i = 0; i < 10 ; i++) {
            int finalI = i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+ finalI);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    /**
     * newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，
     * 可灵活回收空闲线程，若无可回收，则新建线程。
     */
    public static void testNewCachedThreadPool(){

        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 10 ; i++) {
            int finalI = i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+":"+ finalI);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }


    public static void main(String[] args) {
        /**
         * 有序执行，只有1个线程
         */
//        testNewSinglethreadExecutor();
        /**
         * 无序执行，可以指定线程个数（核心线程和最大线程相等）
         */
//        testNewFixedThreadPool();
        /**
         * 有序的，可指定核心线程个数
         */
//        testNewScheduledThreadPool();

        /**
         * 无序不可指定线程个数
         */
        testNewCachedThreadPool();

    }
}

6、备注：

查看源码，四种线程池都是创建了ThreadPollExecutor对象，只是传递的参数不一样而已，观察传入的workQueue 都是默认，即最大可添加Integer.MAX_VALUE个任务，这也就是阿里巴巴java开发规范禁止直接使用java提供的默认线程池的原因了