并发编程——并发基础：守护线程和非守护线程

前言

最近在复习的时候，发现一个运行线程池拒绝策略demo中的main方法在运行了之后，进程并没有关闭。看了jconsole线程池中的线程都处于waiting状态。这里是跟我设置线程池的线程工厂中的设置线程是否为后台线程有关。

后台线程和非后台线程

后台线程，也叫守护线程，指的是在程序运行的时候后台提供一种通用服务的线程，比如jvm里垃圾回收线程，这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要有任何非守护线程在运行，程序就不会终止。

守护线程和非守护线程的区别：在于jvm的离开：如果用户线程（非守护线程）已经全部退出运行了，只剩下守护线程存在，那么虚拟机也就退出了。因为没了被守护者，守护线程也就没有工作可做了。

设置守护线程是通过调用Thread对象的setDaemon(true)方法来实现的。在使用守护线程的时候需要注意以下几点：

（1）thread.setDeaemon(true)必须在thread.start()之前设置，否则会报错IllegalThreadStateException

（2）在Daemon线程中产生的线程也是Daemon的。

（3）守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生终端。

不退出程序的代码

这里在main方法结束之后不能正常退出的代码是测试了线程池两种抛出拒绝策略的场景：

（1）线程池处于SHUTDOWN状态时，再提交新的任务到线程池

（2）线程池中所有的线程都处于运行状态，并且阻塞队列已满，这时再去提交新的线程。

public class ThreadPoolExecutorRejectNewTaskDemo {

    /**
     * 线程池的最大容量
     */
    private static final int MAX_POOL_SIZE = 3;
    /**
     * 阻塞队列的容量
     */
    private static final int QUEUE_CAPACITY = 2;
    /**
     * 非核心线程处于空闲状态的最长时间
     */
    private static final int KEEP_ALIVE_TIME = 1;
    /**
     * 线程池对象 注意这里传入的是默认的拒绝策略 也就是AbortPolicy
     */
    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(MAX_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME,
            TimeUnit.SECONDS, new LinkedBlockingDeque<>(QUEUE_CAPACITY), new MyThreadFactory("task-reject"));

    public static void main(String[] args) {
//        shutdownThreadPoolToRejectNewTask();
        fullQueueThreadPoolRejectNewTask();
    }

    /**
     * 模拟线程池被关闭之后， 继续向其中提交新任务被拒绝的场景
     */
    private static void shutdownThreadPoolToRejectNewTask() {
        MyRunnable runnable = new MyRunnable();

        // 先提交 MAX_POOL_SIZE - 1个任务，此时线程池未满
        for (int i=0; i < MAX_POOL_SIZE - 1; i++) {
            System.out.println("提交任务 " + i);
            threadPool.submit(runnable);
        }
        // 在线程池未满的情况下关闭线程池
        threadPool.shutdown();
        if (threadPool.isShutdown()) {
            System.out.println("提交任务" + MAX_POOL_SIZE);
            // 在线程池未满 但却关闭的情况下去提交任务 此时会拒绝
            threadPool.submit(runnable);
        }
    }

    /**
     * 模拟线程池中线程数都在运行并且阻塞队列已满
     */
    private static void fullQueueThreadPoolRejectNewTask() {
        MyRunnable myRunnable = new MyRunnable();

        // 提交 MAX_POOL_SIZE + QUEUE_SIZE 个任务 使得线程池线程都在执行任务并且阻塞队列已满
        for (int i = 0; i < MAX_POOL_SIZE + QUEUE_CAPACITY; i++) {
            System.out.println("提交任务 " + i);
            threadPool.submit(myRunnable);
        }

        // 此时再去往其中添加 任务
        if (threadPool.getActiveCount() == MAX_POOL_SIZE && threadPool.getQueue().size() == QUEUE_CAPACITY) {
            threadPool.submit(myRunnable);
        }
    }


    /**
     * 自定义线程工厂类
     */
    private static class MyThreadFactory implements ThreadFactory {
        /**
         * namePrefix --> 线程名字中的计数
         */
        private static Map<String, AtomicInteger> THREAD_ID_TABLE = new ConcurrentHashMap<>();
        /**
         * 线程名称前缀
         */
        private String namePrefix;
        /**
         * 是否后台线程
         */
        private boolean isDamon;
        public MyThreadFactory(String namePrefix) {
            this(namePrefix, false);
        }

        public MyThreadFactory(String namePrefix, boolean isDamon) {
            this.namePrefix = namePrefix;
            this.isDamon = isDamon;
        }


        @Override
        public Thread newThread(Runnable r) {
            String threadName = namePrefix + "-" + generateThreadId(this.namePrefix);
            Thread thread = new Thread(r, threadName);
            thread.setDaemon(this.isDamon);
            System.out.println("创建线程" + threadName);
            return thread;
        }

        private static int generateThreadId(String namePrefix) {

            if (!THREAD_ID_TABLE.containsKey(namePrefix)) {
                THREAD_ID_TABLE.putIfAbsent(namePrefix, new AtomicInteger(0));
            }
            return THREAD_ID_TABLE.get(namePrefix).getAndIncrement();
        }
    }

    /**
     * 向线程池提交的任务
     */
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

这段代码中创建新线程的线程工厂中设置了线程池中的线程是否为非后台线程，这里设置的是非后台线程，在我们运行main方法之后，即可观察到main方法一直没退出，而线程池中的线程都处于waiting状态。（这里需要设置下不达到拒绝策略的条件，比如去掉达到拒绝策略的条件之后不再提交任务），这里只是复现这个程序不退出的场景。这里只要把新创建的线程设置为后台线程，当main方法结束之后，线程池中的线程都是守护线程，会随着用户线程的结束也被结束掉。

同样的，我们可以看下Executors提供的一些工具线程池，比如Executors.newFixedThreadPool(int nThreads)

它的构造是使用的默认的线程工厂，我们可以看看默认线程工厂中线程的设置是否为后台线程：

/**
 * The default thread factory
 */
static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

可以看到默认的线程工厂在创建新的线程的时候也是设置daemon为false，这使得定长线程池中都是用户线程，这些个在主线程结束之后，也会使程序不能退出。