Java线程池创建方式和应用场景

素颜马尾好姑娘i 2024-04-08 10:28 110阅读 0赞

#### 目录 ####

*  1.什么是线程池？
 *  2 线程池创建种类
 *   *  2.1通过线程池代码创建线程
     *  2.1.Executors创建的线程池
     *   *  2.1.1 newFixedThreadPool重用固定数量线程的线程池
         *  2.1.2 newWorkStealingPool(int parallelism)抢占式执行的线程池
         *  2.1.3 newSingleThreadExecutor()单例的线程池
         *  2.1.4 newCachedThreadPool()可缓存的线程池
         *  2.1.5 newSingleThreadScheduledExecutor()单线程的可以执行延迟任务的线程池
         *  2.1.6 newScheduledThreadPool(int corePoolSize)周期性的运行任务线程池

--------------------

## 1.什么是线程池？ ##

![在这里插入图片描述][d89e417352284cf98e696d0ad915dc32.png]

## 2 线程池创建种类 ##

### 2.1通过线程池代码创建线程 ###

public void two() throws Exception{
        
            Callable<Integer> callable = new Callable<Integer>() {
        
                @Override
                public Integer call() throws Exception {
        
                    int count=0;
                    for (int i = 0; i < 5; i++) {
        
                        Thread.sleep(1200);
                        count++;
                    }
                    return count;
                }
            };
    
            ExecutorService e= Executors.newFixedThreadPool(10);
            Future<Integer> f1=e.submit(callable);
            Integer result = f1.get();
            System.out.println("获取多线程的值:"+result);
        }

通过上述代码，我们可以知道实现线程池涉及到ExecutorService和Executors。下面我们来一个个进行源码分析

### 2.1.Executors创建的线程池 ###

在idea中，把光标放到Executors上，按住鼠标左键+ctrl进入Executors类。输入alt+7查看该类下的所有方法。  
![在这里插入图片描述][7a54aee9620141c2aff8d05b485a494b.png]

![在这里插入图片描述][66c1f97d79e84a72a7f25f89a12e40ca.png]

#### 2.1.1 newFixedThreadPool重用固定数量线程的线程池 ####

创建一个重用固定数量线程的线程池，如果在所有线程都处于活动状态时提交了额外的任务，他们将在队列中等待，直到线程可用为止。

public class FixedThreadPoolDemo {
        
     
        public static void main(String[] args) {
        
     
            // 创建 2 个线程的线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(2);
            // 创建任务
            Runnable runnable = () -> System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
            // 线程池执行任务(一次添加 8 个任务)
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
            threadPool.execute(runnable);
        }
     
    }

![在这里插入图片描述][8da5f137f3b04f4f98a0e90c307ede18.png]

#### 2.1.2 newWorkStealingPool(int parallelism)抢占式执行的线程池 ####

jdk1.8后引入的，它是新的线程池类ForkJoinPool的扩展，能够合理的使用CPU,进行并发运行任务。  
创建一个线程池，维护足够的线程以支持给定的并行度级别，并且可以使用多个队列来减少争用

// 创建一个线程池，维护足够的线程以支持给定的并行度级别，并且可以使用多个队列来减少争用。
            // 并行度级别对应于主动参与或可用于参与任务处理的最大线程数。
            // 线程的实际数量可能会动态增长和收缩。
            // 工作窃取池不保证提交任务的执行顺序。
            // 并行度——目标并行度级别
            //一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。
            ExecutorService forkJoin = Executors.newWorkStealingPool();
            forkJoin.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("i====>" + 1);
                }
            });
            forkJoin.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("i====>" + 2);
                }
            });
            forkJoin.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("i====>" + 3);
                }
            });
            forkJoin.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("i====>" + 4);
                }
            });
            forkJoin.shutdown();

![在这里插入图片描述][ed57440a82a844f08416b8048d94bb07.png]

#### 2.1.3 newSingleThreadExecutor()单例的线程池 ####

创建一个单例的线程池，也就是说池中就一个线程。通过这个线程来处理所有的任务，如果发现这个这个线程因为失败而关闭，不要慌，会有一个线程来取代他，保证任务能正常的运转

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class NewSingleThreadExecutor {
        
        public static void main(String[] args) {
        
            ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 10; i++) {
        
                final  int index=i;
                singleThreadExecutor.execute(new Runnable() {
        
    
                    @Override
                    public void run() {
        
                        try {
        
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        if(index == 5){
           //故意搞破坏
                            int flag =index/0;
                        }
                        System.out.println(Thread.currentThread().getName());
                    }
                });
            }
        }
    }

#### 2.1.4 newCachedThreadPool()可缓存的线程池 ####

创建一个可缓存的线程池，若线程数超过所需，那么多余的线程会被缓存一段时间后再回收，若线程数不够，则会新建线程。

public class CachedThreadPoolDemo {
        
     
        public static void main(String[] args) {
        
     
            // 创建线程池
            ExecutorService threadPool = Executors.newCachedThreadPool();
            // 执行任务
            for (int i = 0; i < 5; i++) {
        
                threadPool.execute(() -> {
        
                    System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
                });
            }
        }
     
    }

![在这里插入图片描述][58667ca848ed4b7f9835a0316c1b28e1.png]

#### 2.1.5 newSingleThreadScheduledExecutor()单线程的可以执行延迟任务的线程池 ####

创建一个单线程的可以执行延迟任务的线程池。这种线程池可以看做是 ScheduledThreadPool 的单线程版本。

public class SingleThreadScheduledExecutorDemo {
        
     
        public static void main(String[] args) {
        
            // 创建线程池
            ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
            // 添加定时执行任务(2s 后执行)
            System.out.println("添加任务,时间:" + new Date());
            threadPool.schedule(() -> {
        
                System.out.println("任务被执行,时间:" + new Date());
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
        
                }
            }, 2, TimeUnit.SECONDS);
        }
     
    }

![在这里插入图片描述][e478a1bc1efa4f1eb330b813150c43db.png]

#### 2.1.6 newScheduledThreadPool(int corePoolSize)周期性的运行任务线程池 ####

此线程池的的线程可以定时周期性的运行任务。注意坑点：使用这种方法，如果出现异常，会导致无法正常的运行任务。所以，个人建议，使用这种方式的时候，run方法里面的代码可以加上异常处理逻辑。这种方式newSingleThreadExecutor类似，只是增加了周期性运行，这里不过多的阐述。  
![在这里插入图片描述][101f9748ff24466181628887244513e9.png]

public class NewScheduledThreadPool {
        
        public static void main(String[] args) {
        
            ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
            executorService.scheduleAtFixedRate(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("开始时间："+Thread.currentThread().getName()+","+new Date());
                    try {
        
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            },2000,6000,TimeUnit.MILLISECONDS);
        }
    }

通过截图我们可以发现是6秒一次。

保证period>initialDelay，以period为准。以period的时长为一个周期  
如果run方法运行时间大于period，定时任务的周期以run运行时长为一个周期。  
![在这里插入图片描述][2e9126f681e64f0fa8f3c2e51ef3138c.png]

[d89e417352284cf98e696d0ad915dc32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/66f23134520e4880b6a0ef6908514656.png
[7a54aee9620141c2aff8d05b485a494b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/6627df54107d4cdb97ea6bf4e224d4e3.png
[66c1f97d79e84a72a7f25f89a12e40ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/e6a11dbc6871413aac9f51373f810b6a.png
[8da5f137f3b04f4f98a0e90c307ede18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/46ac22acd9114710b65f9709a79e9ee5.png
[ed57440a82a844f08416b8048d94bb07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/e4fde4ed09724a54b62b4e576b9a6d1b.png
[58667ca848ed4b7f9835a0316c1b28e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/f64df2bde85943379ef964e10a194df3.png
[e478a1bc1efa4f1eb330b813150c43db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/c7de189732ee42fa8730d86bf443bcf6.png
[101f9748ff24466181628887244513e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5084ed38ca44409a921676ce5bdc9a2c.png
[2e9126f681e64f0fa8f3c2e51ef3138c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/847d1b16f5334fe091205c6e4f2ac498.png