Java线程池ThreadPool

可分为JDK自带的线程池和自定义线程池

JDK自带的三种线程池

Executors.newFixedThreadPool(N);//一池N线程
Executors.newSingleThreadExecutor();//一池一线程
Executors.newCachedThreadPool();//一池可扩容线程（由程序自行决定池的大小）

一池N线程newFixedThreadPool

	//一池N线程，如果线程池满了，后续的等待，直到池里有空闲线程再处理
    @Test
    public void test(){
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5);//一池5线程
        System.out.println("一池5线程，如：1个银行，5个柜台。");
        //模拟10个顾客请求
        try {
            for (int i = 0; i <= 10; i++) {
                //执行
                threadPool1.execute(() ->{
                    System.out.println(Thread.currentThread().getName()+"号窗口办理业务");
                });
            }
        }catch (Exception e){
            throw new RuntimeException(e);
        }finally {
            //关闭
            threadPool1.shutdown();
        }
    }

一池一线程newSingleThreadExecutor

//一池一线程，如果当前线程有任务正在处理，后续的等待，直到有空闲线程再处理。
    @Test
    public void test2(){
        ExecutorService threadPool2 = Executors.newSingleThreadExecutor();//一池一线程
        System.out.println("一池一线程，如：1个银行，只有1个柜台可以使用。");
        try {
            for (int i = 0; i <= 10; i++) {
                //执行
                threadPool2.execute(() ->{
                    System.out.println(Thread.currentThread().getName()+"号窗口办理业务");
                });
            }
        }catch (Exception e){
            throw new RuntimeException(e);
        }finally {
            //关闭
            threadPool2.shutdown();
        }
    }

一池可扩容线程newCachedThreadPool

	//一池可扩容线程
    @Test
    public void test3(){
        ExecutorService threadPool3 = Executors.newCachedThreadPool();//一池可扩容线程
        System.out.println("一池一线程，如：1个银行，只有多个柜台可以使用，但是有的可能窗口暂停业务，后又恢复办理业务。有的正常办理业务，后又暂停业务。");
        try {
            for (int i = 0; i <= 10; i++) {
                //执行
                threadPool3.execute(() ->{
                    System.out.println(Thread.currentThread().getName()+"号窗口办理业务");
                });
            }
        }catch (Exception e){
            throw new RuntimeException(e);
        }finally {
            //关闭
            threadPool3.shutdown();
        }
    }

自定义线程池

	//自定义线程池。建议：应当根据系统硬件去设置具体的大小，太大可能导致OOM，太小无法充分利用系统资源。
    private static final ExecutorService customThreadPool = new ThreadPoolExecutor(
            8, //corePoolSize线程池基础线程大小。
            16, //maximumPoolSize线程池最大线程数量。
            60L, //keepAliveTime线程池空闲线程存活时间
            TimeUnit.SECONDS, //TimeUnit线程池空闲线程存活时间keepAliveTime的时间单位，这里设置的单位是秒s
            // new ArrayBlockingQueue<>(1000), //BlockingQueue线程池工作队列和长度。ArrayBlockingQueue是有界的数组队列。建议：如果业务量很大，建议使用ArrayBlockingQueue。
            new LinkedBlockingQueue<>(), //BlockingQueue线程池工作队列。LinkedBlockingQueue是无界的链表队列，可能会堆积大量的请求，从而导致 OOM。建议：确保业务量不大并且系统硬件资源足够支持业务的情况下，可以使用LinkedBlockingQueue
            Executors.defaultThreadFactory(), //threadFactory设置创建线程的工厂
            /*
              拒绝处理策略
              AbortPolicy()：默认策略，直接丢弃并抛出异常。如果业务量很大，建议使用此策略抛出异常，捕获异常，对异常进行处理。如：记录日志或持久化不能处理的任务。
              DiscardPolicy()：直接丢弃，不抛出异常。
              DiscardOldestPolicy()：丢弃队列中最早的任务，腾出此线程，将等待的任务放入此线程。
              CallerRunsPolicy()：如果线程池满了，则交由主线程执行。建议：确保业务量不大并且系统硬件资源足够支持业务的情况下，可以使用CallerRunsPolicy。
             */
            new ThreadPoolExecutor.CallerRunsPolicy()); //handler拒绝策略，即：线程池里的线程满了，后面新进来的请求如何处理。
    
    //自定义线程池
    @Test
    public void test() {
        System.out.println("自定义线程池");
        try {
            for (int i = 0; i <= 20; i++) {
                //执行
                customThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + "号窗口办理业务"));
            }
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
        finally {
            //关闭
            customThreadPool.shutdown();
        }
    }

总结

阿里Java开发手册（黄山版）：【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：

1. FixedThreadPool 和 SingleThreadPool：
   允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2. CachedThreadPool：
   允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
3. ScheduledThreadPool：
   允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

根据阿里Java开发手册的建议，我们应该通过 ThreadPoolExecutor 的方式，根据业务量和系统硬件资源，自定义线程池防止OOM。