Java线程池应用的四种方式+线程池底层实现原理

线程池概述

可以有效避免同时创建或销毁多个线程对象造成的抖动问题。在JVM内存空间中，开辟指定空间，先创建指定个数的线程对象，供调用者调用；当已有对象不能满足操作时，则会按照事先设置的最大个数创建线程对象，供调用者调用；当使用完线程池后，一定销毁，降低内存损耗

Java中创建线程池的四种方式

通过 newFixedThreadPool实现

方法：public static ExecutorService newFixedThreadPool(int nThread);

作用：会按照nThread的个数创建线程对象个数，即最大线程对象个数

代码实现：

public class CreateThreadPoolTest {
    public static void main(String[] args) {

        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            int finalI = 1;
            /*
                方法：public void execute(Runnable r)
                作用：通过线程池对象调用指定线程接口实现类，完成线程操作
             */
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"::"+finalI);
                }
            });
        }
            /*
                方法：public void shutdown();
                作用：销毁线程池（必做项）
             */
        pool.shutdown();
    }
}

通过newCachedThreadPool实现

方法：public static ExecutorService newCachedThreadPool();

作用：可伸缩线程池，最大支持同时存储21亿个线程对象，会按照循环操作次数，创建线程对象个数

代码实现：

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

public class CreateThreadPoolTest1 {
    public static void main(String[] args) {

        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 15; i++) {
            int finalI = 1;
           
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"::"+finalI);
                }
            });
        }
        pool.shutdown();
    }
}

通过newSingleThreadExecutor实现

方法：public static ExecutorService newSingleThreadExecutor();

作用：可排序线程池 用于医院银行等叫号系统 只会创建一个线程对象进行处理

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

public class CreateThreadPoolTest2 {
    public static void main(String[] args) {

        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            int finalI = 1;
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"::"+finalI);
                }
            });
        }
        pool.shutdown();
    }
}

通过newScheduledThreadPool实现

方法：public static ExecutorService newScheduledThreadPool(int n);

作用：n表示核心线程数

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

public class CreateThreadPoolTest3 {
    public static void main(String[] args) {

        ExecutorService pool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 24; i++) {
            int finalI = 1;
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"::"+finalI);
                }
            });
        }
        pool.shutdown();
    }
}

线程底层实现原理

底层核心类：ThreadPoolExecutor

线程池七大核心参数

① corePoolSize：核心线程对象个数，即在线程池中初始创建的线程对象个数

② maximumPoolSize：最大线程对象个数，即当且仅当核心线程数不足以支持当前操作时，会按照最大线程对象个数创建非核心线程对象，完成操作

③keepAliveTime：存活时长，即设置非核心线程对象存活的时间

④unit：时间单位，即设置非核心线程对象存活的时间单位

⑤workQueue：工作队列，又称消息队列，主要用于存储等待被处理的对象

⑥threadFactory：线程工厂，主要用于按照最大线程对象个数创建非核心线程对象（线程工厂无需调用，会自动调用父类默认的）

⑦handler：拒绝处理器，主要用于使用Java中定义好的拒绝策略，拒绝消息队列中等待操作的对象，防止线程池中线程对象的过度调用

拓展：自定义线程池

可以通过上面的七个参数来自定义线程池去实现，如图中代码，上传了六个参数，其中线程工厂无需调用，会自动调用父类默认的

public class CreateThreadPoolTest4 {
    public static void main(String[] args) {

        //自定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
          4,
          8,
          30,
          TimeUnit.MINUTES,
          new LinkedBlockingDeque<>(),
          new ThreadPoolExecutor.AbortPolicy()
        );

        for (int i = 0; i < 30; i++) {
            int finalI = 1;
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"::"+finalI);
                }
            });
        }
        pool.shutdown();
    }
}