四种线程池

拼搏现实的明天。 2023-10-11 12:29 12阅读 0赞

先了解一下线程池的作用：  
重用现有的线程，而不是创建新的线程，可以减少开销，因为线程在创建和销毁会有巨大的开销。当请求到达时，工作线程通常是已经存在的，因此不会由于等待创建线程而延迟任务的执行，提高响应性。说白了，就是减少开销，加快时间。

## 1.newFixedThreadPool ##

固定的线程池大小，提交一个任务，创建一个线程，直到达到线程的最大数量，线程池的规模不再变化，比如线程池规模为三，9个任务，第一第二第三个任务为创建线程，后续开始使用前面创建的线程。代码例子如下：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Fixed {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            for (int i=0;i<9;i++){
                executorService.execute(
                        new Runnable() {
                            @Override
                            public void run() {
                                System.out.println(Thread.currentThread().getName()+"正在执行");
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                );
            }
            executorService.shutdown();
        }
    }

执行如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70]

## 2.newCachedThreadPool ##

创建一个可缓存的线程池，如果线程池的当前规模超过了处理需求时，回收空闲的线程，当需求增加时，则可以添加新的线程，线程池的规模不存在限制。其实也可以这样理解，需求多少，创建线程多少。代码例子如下:

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Cached {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newCachedThreadPool();
            for (int i=0;i<9;i++){
                executorService.execute(
                        new Runnable() {
                            @Override
                            public void run() {
                                System.out.println(Thread.currentThread().getName()+"正在执行");
                                try {
                                    Thread.currentThread().sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                );
            }
            executorService.shutdown();
        }
    }

执行如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 1]

## 3.newSingleThreadExecutor ##

单线程，只有一个线程，如果这个线程异常结束，则会创建一个线程来替代。意思为10个任务，让一个线程去执行。例子代码如下：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Single {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            for (int i=0;i<5;i++){
                executorService.execute(
                        new Runnable() {
                            @Override
                            public void run() {
                                System.out.println(Thread.currentThread().getName()+"正在执行");
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                );
            }
            executorService.shutdown();
        }
    }

执行如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 2]

## 4.newScheduledThreadPool ##

固定长度的线程池，支持延迟，和周期执行。  
代码如下

import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class Scheduled {
        public static void main(String[] args) {
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("延迟1S");
                }
            },1, TimeUnit.SECONDS);
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("3s执行一次");
                }
            },0,3,TimeUnit.SECONDS);
        }
    }

执行结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 3]  
到了这里四种线程池都有了了解，在代码中会用到ExecutorService，在newScheduledThreadPool,ScheduledExecutorServer也是继承了ExectorService。ExecutorService也是有生命周期的，运行，关闭和已终止。在ExecutorService中，像我们使用的shutdown()，它是以一种平和的方式结束线程，就是不再接收任务，等待任务执行完毕，包括还没有开始的任务。还有一个是shutdownNow()，很粗暴，直接关闭。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190923164817183.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190923164850460.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190923170633680.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190923171224362.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JheHhkd3lw,size_16,color_FFFFFF,t_70