java线程池的一些概念

package com.hello.world.mock.test;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.junit.Test;

import java.util.concurrent.*;

/**
 * @author xx
 * corePoolSize：核心线程数，当提交一个新的任务到线程池，如果当前线程池运行的线程数（包括闲置的线程）小于核心线程数，则会创建一个新的线程作为核心线程来执行该任务。
 * <p>
 * maximumPoolSize：线程池允许最大的线程数，当提交一个新的任务到线程池，如果当前线程池运行的线程数（包括闲置的线程）大于corePoolSize，小于maximumPoolSize，
 * 并且等待队列满的时候，会创建一个新的线程来处理该任务。
 * <p>
 * keepAliveTime：当线程池中线程数量大于corePoolSize时，闲置线程最长可以存活的时间。
 * <p>
 * unit：时间单位。
 * <p>
 * workQueue：保存任务的队列，当池中线程数大于corePoolSize时，新来的任务保存到该队列。
 * <p>
 * threadFactory：线程工厂，线程池中的线程都是通过这个工厂创建的。
 * <p>
 * handler：任务拒绝执行策略，当线程池无法处理新来任务时的处理策略。
 * ----AbortPolicy：这也是线程池的默认拒绝执行策略。该策略仅会抛出RejectedExecutionException异常，是最简单的策略。
 * ----DiscardPolicy：这个策略的实现其实什么也没做，什么也没有做意味着简单的丢弃任务，也是一个简单的拒绝策略。
 * ----CallerRunsPolicy：调用方执行策略，既然线程池中没有线程可以执行该任务，那就让运行线程池的线程来执行该任务。看下该类的实现：
 * ----DiscardOldestPolicy：丢弃等待队列中最老的任务，并执行新的任务。
 */
public class ThreadPoolTest {

    // org.apache.commons.lang3.concurrent.BasicThreadFactory
    BasicThreadFactory threadFactory = new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build();

    // com.google.common.util.concurrent.ThreadFactoryBuilder;
    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").setDaemon(true).build();

    ThreadFactory defaultThreadFactory = Executors.defaultThreadFactory();

    /*手动创建线程池，效果会更好哦。

    线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

    说明：Executors返回的线程池对象的弊端如下：
    1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
    2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。*/
    @Test
    public void test2() {

        // Common Thread Pool
        ExecutorService pool = new ThreadPoolExecutor(5, 200,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

        // test
        pool.execute(() -> System.out.println(Thread.currentThread().getName()));
        pool.shutdown();//gracefully shutdown

        // 使用默认线程工厂、拒绝策略
        ExecutorService es = new ThreadPoolExecutor(
                8,
                8,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1024));
    }

    /**
     * 任务调度线程池
     */
    @Test
    public void test1() throws InterruptedException {
//        多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，
//        其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10, threadFactory);

        // 按固定间隔，从下一次执行开始计时
        executorService.scheduleAtFixedRate(() -> {
            //do something
            String str = "hi";
            System.out.println(str);
        }, 5, 3, TimeUnit.SECONDS);

        // 按固定间隔，从下一次执行结束计时
        executorService.scheduleWithFixedDelay(() -> {
            //do something
            String str = "hi";
            System.out.println(str);
        }, 5, 3, TimeUnit.SECONDS);

        TimeUnit.HOURS.sleep(10);
    }
}