线程的实现方式，线程池的七大核心参数，JDK默认的工作队列有五种, 拒绝策略

1.线程的实现方式主要有三种：

• 使用继承Thread类的方式来创建线程，重写run方法。
• 使用实现Runnable接口的方式来创建线程，实现run方法。
• 使用Callable和FutureTask来创建线程，实现call方法。

2.线程池的七大核心参数包括： 

• corePoolSize：线程池的核心线程数量。    线程池维护的最小线程数量，核心线程创建后不会被回收（注意：设置allowCoreThreadTimeout=true后，空闲的核心线程超过存活时间也会被回收）。 大于核心线程数的线程，在空闲时间超过keepAliveTime后会被回收。线程池刚创建时，里面没有一个线程，当调用 execute() 方法添加一个任务时，如果正在运行的线程数量小于corePoolSize，则马上创建新线程并运行这个任务.

• maximumPoolSize：线程池的最大线程数量。 线程池允许创建的最大线程数量。当添加一个任务时，核心线程数已满，线程池还没达到最大线程数，并且没有空闲线程，工作队列已满的情况下，创建一个新线程并执行。

• keepAliveTime：空闲线程存活时间。  当线程池中的线程数量超过corePoolSize时,多余的线程在空闲时间超过keepAliveTime后会被销毁。( 当一个可被回收的线程的空闲时间大于keepAliveTime，就会被回收 )                   可被回收的线程：1. 设置allowCoreThreadTimeout=true的核心线程。2. 大于核心线程数的线程（非核心线程）。

• unit：keepAliveTime的时间单位。

                TimeUnit.NANOSECONDS //纳秒
                TimeUnit.MICROSECONDS //微秒
                TimeUnit.MILLISECONDS // 毫秒
                TimeUnit.SECONDS //秒
                TimeUnit.MINUTES //分
                TimeUnit.HOURS //小时
                TimeUnit.DAYS  //天

• workQueue：线程池中的任务队列。存放待执行任务的队列：当提交的任务数超过核心线程数大小后，再提交的任务就存放在工作队列，任务调度时再从队列中取出任务。它仅仅用来存放被execute()方法提交的Runnable任务。工作队列实现了BlockingQueue接口。

                JDK默认的工作队列有五种：

           ①  ArrayBlockingQueue 数组型阻塞队列：数组结构，初始化时传入大小，有界，FIFO，使用一个重入锁，默认使用非公平锁，入队和出队共用一个锁，互斥。
           ②LinkedBlockingQueue 链表型阻塞队列：链表结构，默认初始化大小为Integer.MAX_VALUE，有界（近似无解），FIFO，使用两个重入锁分别控制元素的入队和出队，用Condition进行线程间的唤醒和等待。
           ③ SynchronousQueue 同步队列：容量为0，添加任务必须等待取出任务，这个队列相当于通道，不存储元素。
           ④ PriorityBlockingQueue 优先阻塞队列：无界，默认采用元素自然顺序升序排列。
           ⑤  DelayQueue 延时队列：无界，元素有过期时间，过期的元素才能被取出。

• threadFactory：线程池创建线程的工厂。 创建线程的工厂，可以设定线程名、线程编号等。

    /**
     * The default thread factory
     */
     // 定义了一个名为DefaultThreadFactory的线程工厂类，它实现了ThreadFactory接口。这个线程工厂类的作用是为线程池创建新的线程。
    static class DefaultThreadFactory implements ThreadFactory {

        //在这个类中，定义了几个成员变量：
          //一个原子整型变量，用于为每个线程池生成唯一的标识。
        private static final AtomicInteger poolNumber = new AtomicInteger(1); 
          //一个ThreadGroup对象，用于管理线程池中的线程
        private final ThreadGroup group; 
          //一个原子整型变量，用于为每个线程生成唯一的标识
        private final AtomicInteger threadNumber = new AtomicInteger(1);
          //一个字符串，用于为每个线程生成唯一的名称。
        private final String namePrefix;
         
         //在DefaultThreadFactory的构造函数中，首先获取当前线程的SecurityManager对象。
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();

        //如果存在SecurityManager对象，则使用它来获取当前线程所属的线程组；否则，使用当前线程所属的线程组。
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();

         //使用poolNumber生成一个唯一的标识，并将其添加到namePrefix中，作为每个线程的名称前缀。
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }
 
        public Thread newThread(Runnable r) {
            //在newThread方法中，首先创建一个新的Thread对象
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
           //并将其设置为守护线程（除非明确设置为非守护线程）。然后，将线程的优先级设置为正常优先级（除非明确设置为其他优先级）
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            
            return t;
        }
    }

• handler：线程池的拒绝策略。当线程池线程数已满，并且工作队列达到限制，新提交的任务使用拒绝策略处理。可以自定义拒绝策略，拒绝策略需要实现RejectedExecutionHandler接口。

      JDK默认的拒绝策略有四种：

      ① AbortPolicy - 抛出异常，中止任务。抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行

     ②CallerRunsPolicy - 使用调用线程执行任务。当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大

     ③DiscardPolicy - 直接丢弃，其他啥都没有

     ④ DiscardOldestPolicy - 丢弃队列最老任务，添加新任务。当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

默认拒绝策略：

    /**
     * The default rejected execution handler
     */
//声明了一个静态的RejectedExecutionHandler类型的常量defaultHandler，并将其初始化为AbortPolicy的实例。
    private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

//AbortPolicy类实现了RejectedExecutionHandler接口。 
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }
 
        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */

//rejectedExecution方法是RejectedExecutionHandler接口的方法，当任务被拒绝时会被调用。在这个方法中，它总是抛出一个RejectedExecutionException异常，并提供了有关被拒绝任务和执行器的信息。
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }