Java线程池介绍

￡神魔★判官ぃ 2022-07-12 04:48 235阅读 0赞

什么是线程池？线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。作用类似于数据库连接池。  
　　  
　　Java中线程池的体系结构如下：  
**java.util.concurrent.Executor** : 负责线程的使用与调度的根接口  
　|–**ExecutorService** Executor的子接口: 线程池的主要接口  
　　　|–**ThreadPoolExecutor** ExecutorService的实现类  
　　　|–**ScheduledExecutorService** ExecutorService的子接口：负责线程的调度  
　　　　　|–**ScheduledThreadPoolExecutor** ：既继承了ThreadPoolExecutor，同时实现了ScheduledExecutorService

在实际使用过程中，我们不需要自己手动new出线程池，juc的工具类Executors为我们提供了方法用以创建线程池：  
　　ExecutorService newFixedThreadPool() : 创建固定大小的线程池  
　　ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。  
　　ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程  
　　  
　　ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程池，可以延迟或定时的执行任务。

下面演示使用Executors.newFixedThreadPool()方法创建线程池：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class TestThreadPool { 
    
        public static void main(String[] args) throws Exception {
            // 1. 创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
    
            ThreadPoolDemo tpd = new ThreadPoolDemo();
    
            // 2. 为线程池中的线程分配任务
            for (int i = 0; i < 10; i++) {
                pool.submit(tpd);
            }
    
            // 3. 关闭线程池
            pool.shutdown();
        }
    
    }
    
    class ThreadPoolDemo implements Runnable {
    
        private int i = 0;
    
        @Override
        public void run() {
            while (i <= 100) {
                System.out.println(Thread.currentThread().getName() + " : " + i++);
            }
        }
    }

程序运行结果：  
　　  
　　![image\_1b8kcr492cau9bo1tp4mhkfimm.png-86.6kB][image_1b8kcr492cau9bo1tp4mhkfimm.png-86.6kB]  
　　  
　　除了像上面这段代码中一样使用runnable为线程池中的线程分配任务外，还可以使用callable：

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class TestThreadPool { 
    
        public static void main(String[] args) throws Exception {
            //1. 创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
    
            List<Future<Integer>> list = new ArrayList<>();
    
            for (int i = 0; i < 10; i++) {
                Future<Integer> future = pool.submit(new Callable<Integer>(){
    
                    @Override
                    public Integer call() throws Exception {
                        int sum = 0;
    
                        for (int i = 0; i <= 100; i++) {
                            sum += i;
                        }
                        return sum;
                    }
                });
                list.add(future);
            }
            pool.shutdown();
    
            for (Future<Integer> future : list) {
                System.out.println(future.get());
            }
        }
    }

程序运行结果：  
　　  
　　![image\_1b8kcpq5n1ravtlf6k010t7goc9.png-25.1kB][image_1b8kcpq5n1ravtlf6k010t7goc9.png-25.1kB]  
　　  
　　最后总结一下创建线程的四种方式：  
1. 继承Thread  
2. 实现runnable  
3. 实现callable  
4. 使用线程池

[image_1b8kcr492cau9bo1tp4mhkfimm.png-86.6kB]: /images/20220711/ad7b7ec975de4364935abe717cedc872.png
[image_1b8kcpq5n1ravtlf6k010t7goc9.png-25.1kB]: /images/20220711/9595f055cf9641bb96df4b49bbf302e1.png