java中线程池最实用的创建与关闭指南

目录

• 前言
• 线程池创建
• 只需要执行shutdown就可以优雅关闭
• 执行shutdownNow关闭的测试
• 总结

前言

在日常的开发工作当中，线程池往往承载着一个应用中最重要的业务逻辑，因此我们有必要更多地去关注线程池的执行情况，包括异常的处理和分析等。

线程池创建

避免使用Executors创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用ThreadPoolExecutor的构造函数来自己创建线程池。在创建的同时，给BlockQueue指定容量就可以了。

private static ExecutorService executor = new ThreadPoolExecutor(10, 10,
        60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue(10));

这种情况下，一旦提交的线程数超过当前可用线程数时，就会抛出java.util.concurrent.RejectedExecutionException，这是因为当前线程池使用的队列是有边界队列，队列已经满了便无法继续处理新的请求。但是异常（Exception）总比发生错误（Error）要好。

除了自己定义ThreadPoolExecutor外。还有其他方法。这个时候第一时间就应该想到开源类库，如apache和guava等。

推荐使用guava提供的ThreadFactoryBuilder来创建线程池。

public class ExecutorsDemo {

    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    private static ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {

        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            pool.execute(new SubThread());
        }
    }
}

只需要执行shutdown就可以优雅关闭

package com.zxd.concurrent;

import com.google.common.collect.Lists;

import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPool {

    public static void main(String[] args) {
        // TODO 如何正确优雅简单的关闭线程池 ，无须其他多余操 ；创建线程池我选择用这种方法比较可靠
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
        //接收处理数据的结果集合
        List<Integer> resList = Lists.newArrayList();
        //开启的任务 我们设置的核心处理线程数5个所以 会有多出来的线程在队列中等待
        for (int i = 0; i < 30; i++) {
            executor.execute(new Task(i, resList));
        }
        //1、关闭线程池 一定要在循环结束关闭
        //2、这个关闭方法不会立即关闭所有在执行的任务线程，
        executor.shutdown();
        //4.这里是检查线程池是否所有任务都执行完毕关闭
        int j = 0;
        while (true) {
            //5.这里是等线程池彻底关闭以后做的判断 保证所有线程池已经全部关闭退出while循环
            if (executor.isTerminated()) {
                System.out.println("所有线程已经运行完毕:" + j);
                break;
            }
            // 为避免一直循环 加个睡眠
            try {
                //如果执行shutdown方法没有关闭的线程池线程池会尝试关闭
                System.out.println("尝试关闭线程次数:" + j);
                j++;
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //FIXME 3、下面的方法会立即关闭线程池，没有执行完的也不会在执行了，如果有等待队列的任务也不会继续执行
        System.out.println("【完成的总线程数】：" + resList.size());

    }

    static class Task implements Runnable {
        int name;

        List<Integer> list;

        public Task(int name, List<Integer> list) {
            this.name = name;
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                int j = i * 10;
                // 做业务处理
                //System.out.println("task " + name + " is running");
            }
            list.add(name + 1);
            System.out.println("task " + name + " is over");
        }
    }

}

输出结果

task 0 is over
task 3 is over
task 1 is over
task 2 is over
task 7 is over
task 6 is over
task 5 is over
尝试关闭线程次数:0
task 10 is over
task 9 is over
task 4 is over
task 8 is over
task 14 is over
task 13 is over
task 12 is over
task 11 is over
task 18 is over
task 17 is over
task 16 is over
task 15 is over
task 22 is over
task 21 is over
task 20 is over
task 19 is over
task 26 is over
task 25 is over
task 24 is over
task 23 is over
task 29 is over
task 28 is over
task 27 is over
所有线程已经运行完毕:1
【完成的总线程数】：30

执行shutdownNow关闭的测试

package com.zxd.concurrent;

import com.google.common.collect.Lists;

import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPool {

    public static void main(String[] args) {
        // TODO 如何正确优雅简单的关闭线程池 ，无须其他多余操 ；创建线程池我选择用这种方法比较可靠
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
        //接收处理数据的结果集合
        List<Integer> resList = Lists.newArrayList();
        //开启的任务 我们设置的核心处理线程数5个所以 会有多出来的线程在队列中等待
        for (int i = 0; i < 200; i++) {
            executor.execute(new Task(i, resList));
        }
        //1、关闭线程池 一定要在循环结束关闭
        //2、这个关闭方法不会立即关闭所有在执行的任务线程，
//        executor.shutdown();
        //FIXME 3、下面的方法会立即关闭线程池，没有执行完的也不会在执行了，如果有等待队列的任务也不会继续执行
        List<Runnable> list = executor.shutdownNow();
        System.out.println("c剩余的没有执行的任务【线程数】= " + list.size());
        System.out.println("【完成的总线程数】：" + resList.size());
        //4.这里是检查线程池是否所有任务都执行完毕关闭
        int j = 0;
        while (true) {
            //5.这里是等线程池彻底关闭以后做的判断 保证所有线程池已经全部关闭退出while循环
            if (executor.isTerminated()) {
                System.out.println("所有线程已经运行完毕:" + j);
                break;
            }
            // 为避免一直循环 加个睡眠
            try {
                //如果执行shutdown方法没有关闭的线程池线程池会尝试关闭
                System.out.println("尝试关闭线程次数:" + j);
                j++;
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class Task implements Runnable {
        int name;

        List<Integer> list;

        public Task(int name, List<Integer> list) {
            this.name = name;
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                int j = i * 10;
                // 做业务处理
                //System.out.println("task " + name + " is running");
            }
            list.add(name + 1);
            System.out.println("task " + name + " is over");
        }
    }

}

输出结果

总结

到此这篇关于java中线程池最实用的创建与关闭的文章就介绍到这了,更多相关java线程池创建与关闭内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！