Java中的线程池

一：什么是线程池

线程池就是用来管理和复用线程的工具，它可以减少线程的创建和销毁开销。

举个例子：

现有一个建筑公司，

它现在需要做一个A项目，该项目需要5个人，该项目需要招聘5个临时工来做这个工作，做完工作后结算工钱走人！

过了一段时间，

公司又做一个B项目，该项目需要8个人，那么该项目还需招聘8个临时来做这个工作，做完工作后结算工钱走人！

这样非常麻烦 >_>!!

因此现在就开辟了一个线程池，把5个临时工放入线程池中，让其变成了该公式的员工，其设置为核心线程池为5，即其核心工人为5；

之后如果项目需要的人多与5个，就再找临时工，如果需要的人少于5个就，从核心工人中选；

二：如何创建一个线程池

//创建一个线程池
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,factory,handler);

其中线程池中又7个参数，其中分别为：

核心线程数，最大线程数，保持存活的时间，设置时间的单位，阻塞队列，线程池中的线程工厂，拒绝策略处理器；

三：创建一个线程池，并用execute/submit方法执行任务

1.线程池的执行流程

第一步：创建线程池；

第二步：用execute方法执行任务

第三步：线程执行完毕后，线程并不会立即销毁，而是继续保持在池中等待下一个任务

第四步：当线程空闲时间超出指定时间，且当前线程数量大于核心线程数时，线程会被回收

2.例子（用execute方法执行任务）：

public static void main(String[] args) {
        //核心线程数
        int corePoolSize = 5;
        //最大线程数
        int maximumPoolSize = 10;
        //保持存活的时间 -- 刨除去核心线程数，不超过最大的线程数，其他多余的临时线程的存活时间为1s
        //也就是说，线程数超过核心的线程数，空闲的时间超过keepAliveTime，就会销毁非核心线程
        long keepAliveTime = 1;
        //设置时间的单位，为s
        TimeUnit unit =TimeUnit.SECONDS;
        //阻塞队列（现有线程数多余最大的线程数，就是多余的线程，就需要阻塞队列，让其等待）
        BlockingDeque<Runnable> workQueue =new LinkedBlockingDeque<>();
        //线程池中的线程工厂 -- 默认创建我们的线程
        ThreadFactory factory=Executors.defaultThreadFactory();
        //拒绝策略处理器  ,当超过线程池的最大线程数，并且，其阻塞队列也放不下的时候，会用拒绝策略处理器，进行拒绝
        ThreadPoolExecutor.AbortPolicy handler =new ThreadPoolExecutor.AbortPolicy();
        //创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,factory,handler
                );

        //使用线程池
        for (int i = 0; i < 30; i++) {
            poolExecutor.execute(
                    ()->{
                        System.out.println("当前的线程为"+Thread.currentThread().getName()+"正在执行");
                    }
            );
        }
        poolExecutor.shutdown();
    }

运行结果：

3.例子(并用submit方法执行任务)：

 public static void main(String[] args) {
        //核心线程数
        int corePoolSize = 5;
        //最大线程数
        int maximumPoolSize = 10;
        //保持存活的时间 -- 刨除去核心线程数，不超过最大的线程数，其他多余的临时线程的存活时间为1s
        //也就是说，线程数超过核心的线程数，空闲的时间超过keepAliveTime，就会销毁非核心线程
        long keepAliveTime = 1;
        //设置时间的单位，为s
        TimeUnit unit =TimeUnit.SECONDS;
        //阻塞队列（现有线程数多余最大的线程数，就是多余的线程，就需要阻塞队列，让其等待）
        BlockingDeque<Runnable> workQueue =new LinkedBlockingDeque<>();
        //线程池中的线程工厂 -- 默认创建我们的线程
        ThreadFactory factory=Executors.defaultThreadFactory();
        //拒绝策略处理器  ,当超过线程池的最大线程数，并且，其阻塞队列也放不下的时候，会用拒绝策略处理器，进行拒绝
        ThreadPoolExecutor.AbortPolicy handler =new ThreadPoolExecutor.AbortPolicy();
        //创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,factory,handler
                );

        //使用线程池
        List<Object> f =new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            Future<?> future = poolExecutor.submit(
                    ()->{
                        String s = "当前的线程为" + Thread.currentThread().getName() + "正在执行";
                        System.out.println(s);
                        return s;
                    }
            );
            try {
                Object o = future.get();
                f.add(o);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        poolExecutor.shutdown();
        System.out.println("+++++++++++++++");
        System.out.println("f = " + f);
    }

运行结果