线程中开启线程池异步处理，主副线程设置执行顺序

一 : 问题描述

最近同事碰到了一个性能问题，需要使用线程池开启多线程来执行任务，同时需要线程池中每个都执行完成之后，开启副线程。
那么一个一个来解决问题

二 : 线程先后顺序

方法有很多，可以设置标志位，设置监听，也可以使用线程自带的join
下面使用线程join来实现

public class Test {
	public static void main(String[] args) throws Exception{
		Thread thread = new Thread(() -> {
			try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("=====Thread=====" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss SSS"));
        });
        thread.start();
        thread.join();
        System.out.println("=====Main=====" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss SSS"));
	}
}

上述方法使用了join()，其意思是放弃当前正在执行的线程，并返回对应的线程。
主线程main中调用thread1的join()方法，主线程main放弃正在执行的main线程，即CPU的控制权，返回thread1线程，等待thread1线程执行完成后，才到主线程main执行。

运行结果如下，先打印了Thread，后打印了Main

当将下面代码注释

thread1.join();

运行结果如下，先打印了Main，后打印了Thread

三 : 实现功能

现在有三个线程需要来处理
A：定义为主线程，为代码中的Main线程
B：定义为子线程，为代码中new的thread线程
C：定义为子线程中的多线程，为线程池中多个sonThread线程
代码如下：

package com;

import org.apache.commons.lang.time.DateFormatUtils;
import java.util.Date;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Test().sonThreadMethood();
            System.out.println("=====Thread=====" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss SSS"));
        });
        thread.start();
        thread.join();
        System.out.println("=====Main=====" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss SSS"));
    }

    private void sonThreadMethood() {
        ExecutorService pool = new ThreadPoolExecutor(100, 200, 200,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for(int i = 0; i < 10; i++){
            pool.execute(new sonThread());
        }
        try {
            //等待所有线程执行完毕当前任务。
            pool.shutdown();
            boolean loop = true;
            do {
                //等待所有线程执行完毕当前任务结束
                loop = !pool.awaitTermination(200, TimeUnit.MILLISECONDS);//等待200豪秒
            } while (loop);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    class sonThread implements Runnable {
        @Override
        public void run() {
            System.out.println("=====SON=====" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss SSS"));
        }
    }
}

打印结果如下：

如此便实现了，两个线程设置先后顺序，线程中执行多线程操作。

四 : 线程池简要说明

ExecutorService pool = new ThreadPoolExecutor(1, 1, 1, TimeUnit.MILLISECONDS, 
new ArrayBlockingQueue<Runnable>(1), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());

corePoolSize：线程池核心线程数量（程序运行的正常线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去。

maximumPoolSize：线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，工作队列满了以后，会继续创建线程，直到线程数量大于maximumPoolSize后抛执行错误策略，注意maximumPoolSize要大于corePoolSize，否则抛异常。

keepAliveTime：闲置时间（当线程数大于corePoolSize，且有闲置的线程，则多余的线程经过了keepAliveTime时间后会被销毁）。

unit：描述keepAliveTime的单位。

workQueue：工作队列，当线程数大于corePoolSize时，会进入工作队列进行等待。即被添加到线程池中，但尚未被执行的任务。它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种。

threadFactory：线程工厂，用于创建线程，一般用默认即可。

handler：拒绝策略，当线程数超过maximumPoolSize后，任务太多来不及处理时，如何拒绝任务。

线程执行步骤如下：

OK，整理到这吧！

如有不正确之处，还望指正！书写不易，觉得有帮助就点个赞吧！☺☺☺