线程池的拒绝策略

若线程池中的核心线程数被用完且阻塞队列已排满，则此时线程池的资源已耗尽，线程池将没有足够的线程资源执行新的任务。为了保证操作系统的安全，线程池将通过拒绝策略处理新添加的线程任务。

1. AbortPolicy

第一种拒绝策略是 AbortPolicy，这种拒绝策略在拒绝任务时，会直接抛出一个类型为
RejectedExecutionException的RuntimeException，让你感知到任务被拒绝了，于是你便可以根据业务逻辑选择重试或者放弃提交等策略。

2.DiscardPolicy

第2种拒绝策略是 DiscardPolicy，这种拒绝策略正如它的名字所描述的一样，当新任务被提交后直接被丢弃掉，也不会给你任何的通知，相对而言存在一定的风险，因为我们提交的时候根本不知道这个任务会被丢弃，可能造成数据丢失。

3.DiscardOldestPolicy

第3种拒绝策略是 DiscardOldestPolicy，如果线程池没被关闭且没有能力执行，则会丢弃任务队列中的头结点，通常是存活时间最长的任务，这种策略与第二种不同之处在于它丢弃的不是最新提交的，而是队列中存活时间最长的，这样就可以腾出空间给新提交的任务，但同理它也存在一定的数据丢失风险。

4.CallerRunsPolicy

第4种拒绝策略是 CallerRunsPolicy，相对而言它就比较完善了，当有新任务提交后，如果线程池没被关闭且没有能力执行，则把这个任务交于提交任务的线程执行，也就是谁提交任务，谁就负责执行任务。这样做主要有两点好处。

1. 第一点新提交的任务不会被丢弃，这样也就不会造成业务损失。
2. 第二点好处是，由于谁提交任务谁就要负责执行任务，这样提交任务的线程就得负责执行任务，而执行任务又是比较耗时的，在这段期间，提交任务的线程被占用，也就不会再提交新的任务，减缓了任务提交的速度，相当于是一个负反馈。在此期间，线程池中的线程也可以充分利用这段时间来执行掉一部分任务，腾出一定的空间，相当于是给了线程池一定的缓冲期。

线程池工具类

package com.yzp.jdk.threadutil;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * @ProjectName springbootsamples2_3_6
 * @Description 线程工具类
 * @Author yaozhenpeng
 * @Time 2022/12/20 14:47
 */
public class ThreadUtil {
    /**
     * 默认超时时间
     */
    private static final long TIME_DEFAULT = 120L;
    
    /**
     * 默认最小超时时间
     */
    private static final long TIME_MIN = 30L;
    
    /**
     * 默认最大超时时间
     */
    private static final long TIMEOUT_MAX = 180L;

    /**
     * CallerRunsPolicy策略的线程工厂
     */
    private static final ThreadFactory callerFactory =new ThreadFactoryBuilder().setNameFormat("yzp线程工厂").build();

    /**
     * CallerRunsPolicy策略的线程执行服务
     */
    private static final ExecutorService callerService = new ThreadPoolExecutor(100,200,0,
            TimeUnit.MILLISECONDS,new LinkedBlockingQueue<>(100),callerFactory,new ThreadPoolExecutor.CallerRunsPolicy);

    /**
     *
     * @param tasks 任务集合
     * @param timeoutSeconds 超时时间
     * @return
     */
    public static boolean processByCallerRun(List<Runnable> tasks, long timeoutSeconds){
        return asyncProcessThenWait(tasks,timeoutSeconds,callerService);
    }
    /**
     * 异步执行线程
     * @param tasks 任务集合
     * @param timeoutSeconds 超时时间，如果小于最小时间或超过最大时间则为默认时间 120L
     * @param pool 线程执行服务
     * @return 线程执行完毕返回true,执行超时或发生异常返回false
     */
    private static boolean asyncProcessThenWait(List<Runnable> tasks, long timeoutSeconds, Executor pool){
        if(CollectionUtils.isEmpty(tasks){
            return false;
        }
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        try{
            long timeout = TIME_DEFAULT;
            if(timeoutSeconds>=TIME_MIN && timeoutSeconds <= TIMEOUT_MAX){
                timeout=timeoutSeconds;
            }
            for(Runnable task: tasks){
                futures.add(CompletableFuture.runAsync(task,pool).exceptionally(throwable-> {
                    throwable.printStackTrace();
                    return null;
                }));
            }
            CompletableFuture<Void> alldonetask = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
            alldonetask.get(timeout, TimeUnit.SECONDS);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

}