【高薪程序员必看】万字长文拆解Java并发编程！(9-2)：并发工具-线程池

public ThreadPoolExecutor(
    int corePoolSize,//核心线程数(最多保留的线程数)
    int maximumPoolSize,//最大线程数
    long keepAliveTime,//生存时间,针对救急线程
    TimeUnit unit,//时间单位,针对救急线程
    BlockingQueue<Runnable> workQueue,//阻塞队列
    ThreadFactory threadFactory,//线程工厂,创建线程时起名字
    RejectedExecutionHandler handler)//拒绝策略

//创建一个固定大小的线程池:适用于任务量已知,相对耗时的任务
public static ExecutorService newFixedThreadPool(int nThreads) {//传递的线程数
return new ThreadPoolExecutor(
    //核心线程数:nThreads,最大线程数:nThreads
    nThreads, nThreads,//没有救急线程
    0L, TimeUnit.MILLISECONDS,//存活时间:0毫秒
    //阻塞队列:LinkedBlockingQueue无界队列
    new LinkedBlockingQueue<Runnable>());
}

//创建一个缓冲线程池:适用于任务量不断增长,但每个任务执行时间较短的情况
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        //核心线程数:0最大线程数:2,147,483,647
        0, Integer.MAX_VALUE,//没有核心线程,全都是救急线程,且可以无限创建,存活时间为60s
        60L, TimeUnit.SECONDS,//存活时间:60秒
        //阻塞队列:SynchronousQueue同步队列,没有容量,一手交钱一手交货
        new SynchronousQueue<Runnable>(),
    );
}

//创建一个单线程线程池:适用于任务是串行执行,多出来的任务排队
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
    (new ThreadPoolExecutor(
        //核心线程数1,最大线程数1
        1, 1,
        0L, TimeUnit.MILLISECONDS,//存活时间0毫秒
        //阻塞队列:LinkedBlockingQueue无界队列
        new LinkedBlockingQueue<Runnable>()));
}

//创建一个带有任务调用的线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//延时执行任务
public <V> ScheduledFuture<V> schedule(
    //具体执行的任务对象
    Runnable command,
    //延时时间
    long delay,
    TimeUnit unit);
//定时执行任务
public ScheduledFuture<?> scheduleAtFixedRate(
    //具体的执行任务对象
    Runnable command,
    //初始延时时间
    long initialDelay,
    //任务之间的执行延迟时间:从上一次任务开始执行时,延迟时间就开始
    long period,
    TimeUnit unit);
public ScheduledFuture<?> scheduleWithFixedDelay(
    //具体的执行任务对象
    Runnable command,
    //初始延时时间
    long initialDelay,
    //任务之间的执行延迟时间:从上一次任务执行结束时,延迟时间才开始
    long delay,
    TimeUnit unit)

//执行任务
void execute(Runnable command);
//提交任务task,用返回值Future获取任务执行的结果
<T> Future<T> submit(Callable<T> task);
//提交tasks中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException;
//超时时间
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException;
//提交tasks中所有任务,哪个任务先执行完毕,返回此任务的返回结果,其他任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException;
//超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException;

@Slf4j
public class SubmitTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        invokeAny(pool);
    }
    private static void invokeAny(ExecutorService pool) throws InterruptedException, ExecutionException {
        Object result = pool.invokeAny(Arrays.asList(
                () -> {
                    log.debug("running...111");
                    Thread.sleep(new Random().nextInt(10000));
                    log.debug("end...111");
                    return "1";
                },
                () -> {
                    log.debug("running...222");
                    Thread.sleep(new Random().nextInt(10000));
                    log.debug("end...222");
                    return "2";
                },
                () -> {
                    log.debug("running...333");
                    Thread.sleep(new Random().nextInt(10000));
                    log.debug("end...333");
                    return "3";
                }
        ));
        log.debug("执行结果:{}",result);
    }
    private static void invokeAll(ExecutorService pool) throws InterruptedException {
        List<Future<Object>> futures = pool.invokeAll(Arrays.asList(
                () -> {
                    log.debug("running...111");
                    Thread.sleep(new Random().nextInt(10000));
                    return "1";
                },
                () -> {
                    log.debug("running...222");
                    Thread.sleep(new Random().nextInt(10000));
                    return "2";
                },
                () -> {
                    log.debug("running...333");
                    Thread.sleep(new Random().nextInt(10000));
                    return "3";
                }
        ));
        futures.forEach(future -> {
            try {
                log.debug("执行结果:{}", future.get());
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        });
    }
    private static void submit(ExecutorService pool) throws InterruptedException, ExecutionException {
        Future<String> future = pool.submit(() -> {
            log.debug("正在执行");
            Thread.sleep(1000);
            return "任务结束";
        });
        log.debug("执行结果:{}", future.get());
    }
}

/*
1.将线程池状态变为SHUTDOWN
2.不会接受新任务,把剩余任务完成
3.不会阻塞调用线程
*/
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        //修改线程池状态
        advanceRunState(SHUTDOWN);
        //打断空闲的线程
        interruptIdleWorkers();
        onShutdown(); // 扩展点 ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    //尝试终止线程池,检查线程池状态是否为TERMINATED
    tryTerminate();
}

/*
1.将线程池状态变为STOP
2.不会接受新任务,剩余任务抛弃并返回
3.用interrupt打断正在执行任务的线程
*/
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        //修改线程池状态
        advanceRunState(STOP);
        //打断所有线程
        interruptWorkers();
        //将剩余任务返回
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    //尝试终止线程池,检查线程池状态是否为TERMINATED
    tryTerminate();
    return tasks;
}

//检查线程池状态是否处于RUNNING,是返回false,否返true
public boolean isShutdown();
//检查线程池状态是否处于TERMINATED,是返回true,否返false
public boolean isTerminated();
//调用shutdown()方法后,线程池不会等待所有线程任务执行结束
//如果想在线程池TERMINATED后做些事情,可以用此方法等待
public boolean awaitTermination(long timeout, TimeUnit unit)throws InterruptedException