java基本线程池+手动创建线程池简单代码

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * @Description
 * @Author 
 * @Date 
 *
 */
public class CachedThreadPoolDemo {


    private  static final int count = 1000;

    public static void main(String[] args) {
        /**
         * 支持定时及周期性任务执行
         */
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(20);

        /**
         * 定时周期任务线程池
         * 参数1: Runnable接口的实现线程类
         * 参数2: 第一次执行的时间
         * 参数3: 间隔的时间
         * 参数4: 时间单位
         * 下列参数是1秒之后开始执行TestThread() 线程,执行间隔周期为1秒
         */
        scheduledExecutorService.scheduleAtFixedRate(new TestThread(),1,1, TimeUnit.SECONDS);
        try {
            scheduledExecutorService.execute(new TestThread());
        } catch (Exception e) {
            e.printStackTrace();
        }


        ScheduledExecutorService scheduledExecutorService1 = Executors.newScheduledThreadPool(5);
        /**
         * 定时线程池
         *  参数1: Runnable接口的实现线程类
         *  参数2: 开始执行的时间
         *  参数3: 时间单位
         * 下列参数:1秒钟之后开始执行线程
         */
        try {
            scheduledExecutorService.schedule(new TestThread(),1,TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }


        /**
         * 单线程线程池,它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
         */
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        try {
            for (int i = 0; i < count ; i++) {

                try {
                   /* singleThreadExecutor.execute(new Thread());*/
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        /**
         * 可缓存线程池
         * 如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
         */
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < count ; i++) {

            try {
                cachedThreadPool.execute(new Thread());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /**
         * 单例线程池，定期或延时执行任务
         */
        ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();

        try {
            /**
             * 区别:
             *   执行的时间点不同
             * scheduleAtFixedRate:
             *   第三个参数period 是连续执行之间的时间段
             * scheduleWithFixedDelay:
             *  第三个参数:delay 一次执行终止与下一次执行开始的延迟
             *
             *  详细信息:https://blog.csdn.net/jianghuiyun/article/details/96151861
             */
            singleThreadScheduledExecutor.scheduleAtFixedRate(new TestThread(),2,1,TimeUnit.SECONDS);
            singleThreadScheduledExecutor.scheduleWithFixedDelay(new TestThread(),2,1,TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }


        /**
            newWorkStealingPool:
                创建持有足够线程的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争，它需要穿一个并行级别的参数，如果不传，则被设定为默认的CPU数量。

         ForkJoinPool：
                支持大任务分解成小任务的线程池，这是Java8新增线程池，通常配合ForkJoinTask接口的子类RecursiveAction或RecursiveTask使用
        */

        /**
         * 手动创建通用线程池
         * 参数含义：
         *      corePoolSize : 线程池中常驻的线程数量。核心线程数，默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制。除非将allowCoreThreadTimeOut设置为true。
         *      maximumPoolSize : 线程池所能容纳的最大线程数。超过这个数的线程将被阻塞。当任务队列为没有设置大小的LinkedBlockingDeque时，这个值无效。
         *      keepAliveTime : 当线程数量多于 corePoolSize 时，空闲线程的存活时长，超过这个时间就会被回收
         *      unit : keepAliveTime 的时间单位
         *      workQueue : 存放待处理任务的队列，该队列只接收 Runnable 接口
         *      threadFactory : 线程创建工厂
         *      handler : 当线程池中的资源已经全部耗尽，添加新线程被拒绝时，会调用RejectedExecutionHandler的rejectedExecution方法，参考 ThreadPoolExecutor 类中的内部策略类
         */
        ThreadFactoryBuilder threadFactoryBuilder = new ThreadFactoryBuilder();
        ThreadFactory threadFactory = threadFactoryBuilder.setNameFormat("xxx-pool-%d").build();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 200, 0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1024),
                threadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < count ; i++) {
            threadPoolExecutor.execute(() ->
                    System.out.println(Thread.currentThread().getName()));
        }
        threadPoolExecutor.shutdown();
        
		/**
         * 任务拒绝策略
         * ThreadPoolExecutor.AbortPolicy()：被拒绝后抛出RejectedExecutionException异常
         * ThreadPoolExecutor.CallerRunsPolicy()：被拒绝后给调用线程池的线程处理
         * ThreadPoolExecutor.DiscardOldestPolicy()：被拒绝后放弃队列中最旧的未处理的任务
         * ThreadPoolExecutor.DiscardPolicy()：被拒绝后放弃被拒绝的任务(当前新添加的任务)
         */
    }

}

class TestThread implements Runnable{

    @Override
    public void run() {
        System.out.println("aaaa:"+Thread.currentThread().getName());
    }
}