线程池：线程池是什么？、线程池的基本架构、线程池的使用方式、线程池中的七个参数、线程池中底层的工作流程、自定义线程池

1. 线程池是什么？

线程池（thread pool）：一种线程使用模式。线程过多会带来调度开销进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

线程池的优势：线程池做的工作是只要控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

2. 线程池的基本架构

3. 线程池的使用方式

3.1 一池n线程

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

public class 一池n线程 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(5);

        try {
            //5个窗口处理10个顾客的请求
            for (int i = 0; i < 10; i++) {
                pool.execute(() -> System.out.println(Thread.currentThread().getName() + "办理业务"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            pool.shutdown();
        }
    }
}

3.2 一池一线程

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

public class 一池一线程 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        try {
            //1个窗口处理10个顾客的请求
            for (int i = 0; i < 10; i++) {
                executorService.execute(() -> System.out.println(Thread.currentThread().getName() + "正在处理"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

3.3 根据需求创建线程，可扩容，遇强则强

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

public class 一池可扩容线程 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        try {
            for (int i = 0; i < 10; i++) {
                executorService.execute(() -> System.out.println(Thread.currentThread().getName() + "正在处理"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

4. 线程池中的七个参数

5. 线程池中底层的工作流程

教学视频链接

• 当执行了excute()方法时，线程才会被创建
• 常驻线程（core poll）满了，线程会放在阻塞队列
• 常驻线程（core poll）满了，阻塞队列也满了，还有新的线程，则创建常驻线程外的新的线程来处理
• • 常驻线程（core poll）满了，阻塞队列也满了，创建的线程也满了，且还有线程需要处理，就会执行拒绝策略
    
    拒绝策略：
    

6. 自定义线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class 自定义线程 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,//常驻线程数量
                5,//最大线程数量
                2L,//存活时间
                TimeUnit.SECONDS,//单位
                new ArrayBlockingQueue<>(5),//阻塞队列长度
                Executors.defaultThreadFactory(),//默认线程工厂
                new ThreadPoolExecutor.AbortPolicy()//拒绝策略
        );

        //测试
        try {
            //5个窗口处理10个顾客的请求
            for (int i = 0; i < 10; i++) {
                threadPoolExecutor.execute(() -> System.out.println(Thread.currentThread().getName() + "办理业务"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown();
        }
    }
}