简介

线程池是一种用于管理和重用线程的机制，它可以有效地管理线程的创建和销毁，减少线程创建和销毁的开销，并且能够控制并发线程数量，避免资源耗尽和系统过载。Java 提供了java.util.concurrent 包来支持线程池的实现。

1.ThreadPoolExecutor

ThreadPoolExecutor是一种很常用的线程池创建方法。

例如：

ThreadPoolExecutor threadPool = new ThreadPoolExecutor();

其构造方法可以有7个参数，分别为：

corePoolSize:核心线程数

maximumPoolSize:最大线程数

keepAliveTime：最大线程数可以存活的时间，单位有秒，分，小时等。

workQueue：阻塞队列，当线程池满时用来存储线程池等待执行的任务，均为线程安全，其有7种类型。

• ArrayBlockingQueue：数组组成的有界阻塞队列。
• LinkedBlockingQueue：链表组成的有界阻塞队列。
• SynchronousQueue：不存储元素的阻塞队列，即直接提交给线程不保持它们。
• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
• DelayQueue：使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素
• LinkedTransferQueue：链表组成的无界阻塞队列。
• LinkedBlockingDeque：链表组成的双向阻塞队列。

threadFactory：线程工厂，主要用来创建线程。

handler：拒绝策略，拒绝处理任务时的策略，有四种类型(默认为 AbortPolicy)

• AbortPolicy：拒绝并抛出异常
• DiscardPolicy：忽略并抛弃当前任务。
• DiscardOldestPolicy：抛弃队列头部（最旧）的一个任务，并执行当前任务。
• CallerRunsPolicy：使用当前调用的线程来执行此任务。

例子：

    public static void create01(){
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 15, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(20));
        for (int i = 0; i < 5; i++) {
            threadPool.execute(() -> {
                System.out.println("当前线程名为:" + Thread.currentThread().getName());
            });
        }
    }

2.FixedThreadPool

创建⼀个固定⼤⼩的线程池，可控制并发的线程数，超出的线程会在队列中等待.

例如：创建了一个有2个线程的线程池

 ExecutorService threadPool = Executors.newFixedThreadPool(2);

具体例子：

    public static void create02(){
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程名为:" + Thread.currentThread().getName());
            }
        };
        threadPool.submit(runnable);
        threadPool.execute(runnable);
        threadPool.submit(runnable);
        threadPool.execute(runnable);
    }

最后输出如下：可以看到有两种不同的线程，因为线程数被固定为了2，因此上面执行了四个任务，其每个线程都执行了2次。

该线程池有两个提交线程的方法，分别为submit和execute

submit可以执行有返回值的任务和无返回值的任务，而execute只能执行没有返回值的任务

3.CachedThreadPool

创建⼀个可缓存的线程池，若线程数超过处理所需，缓存⼀段时间后会回收，若线程数不够，则新建线程

例子：

    public static void create03(){
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            service.submit(() -> {
                System.out.println("当前线程名为:" + Thread.currentThread().getName());
            });
        }
    }

输出如下：创建了10个线程

4.ScheduledThread

创建一个可以执行延迟任务的线程池

例子：线程中的任务会在5s的延迟后执行

    public static void create04(){
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("任务开始前的时间：" + LocalDateTime.now());
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("现在执行了任务：" + LocalDateTime.now());
            }
        },5, TimeUnit.SECONDS);
    }

5.SingleThreadExecutor

创建单个线程数的线程池，它可以保证先进先出的执行顺序

例子：

    public static void create05(){
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 4; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("当前线程名为:" + Thread.currentThread().getName());
                }
            });
        }
    }

输出为：可以看到使用的都是一个线程

6.SingleThreadScheduledExecutor

同时具备上面两个线程池的特性，创建一个单线程的可以执行延迟任务的线程池。

    public static void create06(){
        ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
        System.out.println("任务开始前的时间：" + LocalDateTime.now());
        threadPool.schedule(() -> {
            System.out.println("现在执行了任务：" + LocalDateTime.now());
        }, 2, TimeUnit.SECONDS);
    }

7.NewWorkStealingPool

创建一个抢占式执行的线程池（任务执行顺序不确定），此方法只有在 JDK 1.8以上的版本中才能使用。

例子：

    public static void create07(){
        ExecutorService threadPool = Executors.newWorkStealingPool();
        for (int i = 0; i < 5; i++) {
            threadPool.execute(() -> {
                System.out.println("线程名为:" + Thread.currentThread().getName());
            });
        }
        while (!threadPool.isTerminated()) {
        }
    }