Java如何创建线程池?项目中如何使用线程池

我就是我 2024-05-05 22:22 10阅读 0赞

#### 文章目录 ####

*  创建方式一(推荐)
 *  创建方式二
 *  项目中如何使用线程池?
 *   *  静态方式
     *  SpringBoot方式
     *  另外
 *  参考

## 创建方式一(推荐) ##

通过ThreadPoolExecutor构造函数来创建（**推荐**）。  
![在这里插入图片描述][34e2de08e767478890687167e564284d.png]

## 创建方式二 ##

通过 Executor 框架的工具类 Executors 来创建。  
我们可以创建多种类型的 ThreadPoolExecutor：

**Executors.newFixedThreadPool(int)：一池N线程**. 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

ExecutorService threadPool1 = Executors.newFixedThreadPool(5); //5个窗口

**Executors.newSingleThreadExecutor()：一池一线程**. 该方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

ExecutorService threadPool2 = Executors.newSingleThreadExecutor(); //一个窗口

**Executors.newCachedThreadPool()：一池可扩容根据需求创建线程**. 该方法返回一个可根据实际情况调整线程数量的线程池。初始大小为0。当有新任务提交时，如果当前线程池中没有线程可用，它会创建一个新的线程来处理该任务。如果在一段时间内（默认为60秒）没有新任务提交，核心线程会超时并被销毁，从而缩小线程池的大小。

ExecutorService threadPool3 = Executors.newCachedThreadPool();

对应 Executors 工具类中的方法如图所示：  
![在这里插入图片描述][ba83676ad89d44d5aea5c5bc2b4596d3.png]  
执行线程：`execute()`  
关闭线程：`shutdown()`  
`void execute(Runnable command);`参数为Runnable接口类，可以通过设置lambda

// 具体案例代码案例
    
    public class ThreadPoolTest {
        
        public static void main(String[] args) {
        
            // 一池N线程
            ExecutorService threadPool1 = Executors.newFixedThreadPool(5);
            // 一池一线程
            ExecutorService threadPool2 = Executors.newSingleThreadExecutor();
            // 一池可扩容根据需求创建线程
            ExecutorService threadPool3 = Executors.newCachedThreadPool();
    
            // 是个顾客请求
            try{
        
                for (int i = 1; i <= 10; i++) {
        
                    // 到此时执行execute()方法才创建线程
                    threadPool2.execute(()->{
        
                        System.out.println(Thread.currentThread().getName()+" 办理业务");
                    });
                }
            }finally {
        
                // 关闭线程
                threadPool1.shutdown();
            }
        }
    }
    一池N线程输出结果为：
    
    pool-1-thread-2 办理业务
    pool-1-thread-1 办理业务
    pool-1-thread-3 办理业务
    pool-1-thread-5 办理业务
    pool-1-thread-4 办理业务
    pool-1-thread-2 办理业务
    pool-1-thread-1 办理业务
    pool-1-thread-4 办理业务
    pool-1-thread-5 办理业务
    pool-1-thread-3 办理业务
    
    一池一线程输出结果为：
    
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    pool-2-thread-1 办理业务
    
    一池可扩容根据需求创建线程输出结果为：
    
    pool-3-thread-1 办理业务
    pool-3-thread-5 办理业务
    pool-3-thread-4 办理业务
    pool-3-thread-7 办理业务
    pool-3-thread-2 办理业务
    pool-3-thread-3 办理业务
    pool-3-thread-8 办理业务
    pool-3-thread-6 办理业务
    pool-3-thread-9 办理业务
    pool-3-thread-10 办理业务

## 项目中如何使用线程池? ##

《阿里巴巴JAVA开发手册》有这样一条强制规定：线程池不允许使用Executors去创建，而应该通过ThreadPoolExecutor方式，这样处理方式更加明确线程池运行规则，规避资源耗尽风险。

public static ExecutorService newFixedThreadPool(int nThreads) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
    }
    public static ExecutorService newSingleThreadExecutor() {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
    }

上面这两种方式创建线程池使用的阻塞队列是LinkedBlockingQueue

/**
     * A constant holding the maximum value an {@code int} can
     * have, 2<sup>31</sup>-1.
     */
    //2的31次方，然后在减1 2147483647
    @Native public static final int   MAX_VALUE = 0x7fffffff;
    public LinkedBlockingQueue() {
        
        this(Integer.MAX_VALUE);
    }

不设大小理论上队列容量无上限，所以可能会堆积大量请求从而导致OOM。  
以上这种方式，就不聊了。  
那么在项目中如何去使用线程池呢?  
在项目中，我们通常有两种方式创建线程池：

*  第一种：静态方式
 *  第二种：使用Spring Boot创建线程池

比如说我们项目中需要处理用户登录日志，但是此时不想因为记录登录日志耽搁了登录。  
如果我们使用同步的方式，可能会因为一些不太需要实时结果的，并且又耗时的业务可能会导致整个业务变慢：  
![在这里插入图片描述][1dbd55fa2e8b4262a6278c06b963aa08.png]  
耗时：200ms=100ms+100ms

如果使用线程池做了异步化后，直接创建个任务丢到线程池里，这样就减少了后面那100ms的等待时间。  
![在这里插入图片描述][f4f8eafa342342f88ad0b68e7a6b10bc.png]  
在实际项目中，也有很多项目使用消息队列来做异步化，这个看项目情况来，比如：开发成本、后期运维成本等。

### 静态方式 ###

静态方式就是当做一种工具类使用，代码实现如下：

package com.tianwc.myblog.pool;
    
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    //这里的相关只是一个演示，大家在定参数时，还是要以具体情况来
    public class ThreadPoolUtil {
        
        //获取CPU核数
        static int cpuNums = Runtime.getRuntime().availableProcessors();
        /** 线程池核心池的大小*/
        private static int corePoolSize = 10;
        /** 线程池的最大线程数*/
        private static int maximumPoolSize = cpuNums * 5;
        //阻塞队列容量
        private static int queueCapacity = 100;
        //活跃时间，
        private static int keepAliveTimeSecond = 300;
    
        public static ExecutorService httpApiThreadPool = null;
    
        static{
        
            System.out.println("创建线程数:"+corePoolSize+",最大线程数:"+maximumPoolSize);
            //建立10个核心线程，线程请求个数超过20，则进入队列等待
            httpApiThreadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTimeSecond,
                    TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(queueCapacity),new ThreadFactoryBuilder().setNameFormat("PROS-%d").build());
        }
    }

在业务代码中的使用

ThreadPoolUtil.httpApiThreadPool.submit(new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("======== 登录日志记录=====start=======");
                        try {
        
                            // TODO: 2022/4/14 业务处理
                            Thread.sleep(1000L);
                            System.out.println("userId=" + userId);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println("========登录日志记录------end=======");
                    }
                }));

但是这种方式存在很多问题，很多项目也是这么在用的。比如想动态修改线程池参数，这种方式就不好处理了  
我们再来看看Spring Boot创建方式；

### SpringBoot方式 ###

配置文件, 我们可以把线程池相关参数配置在配置文件中application.yaml(或者application.properties)。

threadpool:
      corePoolSize: 8  # 获取cpu核数
      maxPoolSize: 16  # 线程池最大线程数
      queueCapacity: 5  # 阻塞队列容量
      keepAliveSeconds: 300  # 活跃时间

然后创建线程池：

package com.tianwc.myblog.pool;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.env.Environment;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import javax.annotation.Resource;
    import java.util.concurrent.ThreadPoolExecutor;
    
    @Configuration
    @EnableAsync // 开启异步请求  在项目中通常是将注解 @EnableAsync 放到项目启动类上
    public class ThreadPoolConfig {
        
    
        @Resource
        private Environment env;
    
        //创建线程池
        @Bean("taskExecutor")
        public ThreadPoolTaskExecutor taskExecutor() {
        
            ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
            pool.setThreadNamePrefix("--------------全局线程池-----------------");
            pool.setCorePoolSize(Integer.parseInt(env.getProperty("threadpool.corePoolSize")));
            pool.setMaxPoolSize(Integer.parseInt(env.getProperty("threadpool.maxPoolSize")));
            pool.setKeepAliveSeconds(Integer.parseInt(env.getProperty("threadpool.queueCapacity")));
            pool.setQueueCapacity(Integer.parseInt(env.getProperty("threadpool.keepAliveSeconds")));
            // 直接在execute方法的调用线程中运行
            pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            // 初始化
            pool.initialize();
            return pool;
        }
    }

在项目中使用：

package com.tianwc.myblog.pool;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    
    @Component
    public class AsynchronousTask {
        
    
        @Async("taskExecutor")
        public void recordLoginLog(Long userId){
        
            System.out.println("======== 登录日志记录=====start=======");
            try {
        
                // TODO: 2022/4/14 业务处理
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("========登录日志记录------end=======");
        }
    }

然后在登录的代码中使用：

@Resource
    private AsynchronousTask asynchronousTask;
    
    public Boolean login(){
        
        //登录处理
        Long userId=10001;
        boolean isSucc=true;
        if(isSucc){
        
            asynchronousTask.recordLoginLog(userId);
        }
        System.out.println("=====登录成功====");
    }

输出日志：

=====登录成功====
    ======== 登录日志记录=====start=======
    userId=10001
    ========登录日志记录------end=======

以上就是项目中通常使用的方式，另外，注意，在项目中通常是将注解@EnableAsync放到项目启动类上。

### 另外 ###

下面这个链接中介绍了使用Spring的使用线程池的案例, 可以看看进行参考  
[https://blog.csdn.net/lingerlan510/article/details/122322588][https_blog.csdn.net_lingerlan510_article_details_122322588]

## 参考 ##

[面试官：在项目中，你是如何使用线程池的？][Link 1]

[34e2de08e767478890687167e564284d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/c0d7c962e54944d89e11467b2f19d92b.png
[ba83676ad89d44d5aea5c5bc2b4596d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/6d3e1ab9ed5e4527b113ca50903167a3.png
[1dbd55fa2e8b4262a6278c06b963aa08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/45ab1335672048a5bf711cf4cc1d0823.png
[f4f8eafa342342f88ad0b68e7a6b10bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/f8dba102c686487db03ffbfb4e724b90.png
[https_blog.csdn.net_lingerlan510_article_details_122322588]: https://blog.csdn.net/lingerlan510/article/details/122322588
[Link 1]: https://cloud.tencent.com/developer/article/1984291