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

痛定思痛。 2023-09-28 18:46 8阅读 0赞

##### 一 : 问题描述 #####

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

##### 二 : 线程先后顺序 #####

方法有很多，可以设置标志位，设置监听，也可以使用线程自带的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  
![在这里插入图片描述][8e3257d692904b0b887df3cbb65d1a34.png]  
当将下面代码注释

thread1.join();

运行结果如下，先打印了Main，后打印了Thread  
![在这里插入图片描述][0f1aad9748274380beb4f3f08cda5832.png]

##### 三 : 实现功能 #####

现在有三个线程需要来处理  
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"));
            }
        }
    }

打印结果如下：  
![在这里插入图片描述][c527793286d8449292d1f7a93bf04768.png]  
如此便实现了，两个线程设置先后顺序，线程中执行多线程操作。

##### 四 : 线程池简要说明 #####

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后，任务太多来不及处理时，如何拒绝任务。

线程执行步骤如下：  
![在这里插入图片描述][8dd2cf78a3534cf8a2c8ab89efd2e762.png]

OK，整理到这吧！

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

[8e3257d692904b0b887df3cbb65d1a34.png]: https://img-blog.csdnimg.cn/8e3257d692904b0b887df3cbb65d1a34.png
[0f1aad9748274380beb4f3f08cda5832.png]: https://img-blog.csdnimg.cn/0f1aad9748274380beb4f3f08cda5832.png
[c527793286d8449292d1f7a93bf04768.png]: https://img-blog.csdnimg.cn/c527793286d8449292d1f7a93bf04768.png
[8dd2cf78a3534cf8a2c8ab89efd2e762.png]: https://img-blog.csdnimg.cn/8dd2cf78a3534cf8a2c8ab89efd2e762.png