为什么要使用线程池？

线程池可以减少线程频繁的创建，销毁。减少系统开销，多线程的情况下确实可以最大限度发挥多核处理器的计算能力，提高系统的吞吐量和性能。
在阿里的《Java开发手册》中对线程有这样的规范:

线程池参数

众所周知线程池有七大参数：

JDK中提供四种工作队列

ArrayBlockingQueue
基于数组的有界阻塞队列，如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
LinkedBlockingQuene
基于链表的无界阻塞队列，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，因此使用该工作队列时，参数maxPoolSize没有作用。
SynchronousQuene
一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
PriorityBlockingQueue 具有优先级的无界阻塞队列，优先级通过参数Comparator实现。 ThreadFactory
threadFactory 线程工厂创建新线程时使用的工厂类，可以设置线程是否为守护线程，设置线程名字。

JDK中有四种默认实现

CallerRunsPolicy 线程池shutdown的话直接不管，没有shutdown在调用者线程中直接执行被拒绝任务的run方法。
AbortPolicy 丢任务，抛出RejectedExecutionException
DiscardPolicy 直接丢任务
DiscardOldestPolicy 抛队列头部任务，把这次拒绝的任务加入队列

代码具体实现

首先实现线程工厂

/**
 * @author 其一
 * @version 1.0
 * @description: TODO
 * @date 2022/1/6 1:53 下午
 */
public class ThreadFactory implements java.util.concurrent.ThreadFactory {
   private static final AtomicInteger POOL_SEQ = new AtomicInteger(1);
   private final AtomicInteger ThreadNum;
   private final String prefix;
   private final boolean Daemo;
   private final ThreadGroup Group;
   public ThreadFactory() {
      this("pool-"+POOL_SEQ.getAndIncrement(),false);
   }
   //默认守护线程
   public ThreadFactory(String prefix) {
      this(prefix,false);
   }
   public ThreadFactory(String prefix, boolean Daemo) {
      this.ThreadNum = new AtomicInteger(1);
      this.prefix = prefix + "-thread-";
      this.Daemo = Daemo;
      SecurityManager s = System.getSecurityManager();
      this.Group = s == null ? Thread.currentThread().getThreadGroup() : s.getThreadGroup();
   }

   @Override
   public Thread newThread(Runnable r) {
      String name= this.prefix+this.ThreadNum.getAndIncrement();
      Thread ret = new Thread(this.Group,r,name,0L);
      ret.setDaemon(this.Daemo);
      return ret;
   }
}

具体使用执行任务

/**
 * @author 其一
 * @version 1.0
 * @description: TODO
 * @date 2022/1/5 6:28 下午
 */
public class ThreadPoolDemo {
   public static void main(String[] args) throws InterruptedException {

      ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors(),
            0L,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(),
            new ThreadFactory("ThreadPoolDemo"),
            new ThreadPoolExecutor.CallerRunsPolicy()
      );
      List<String> strings = new ArrayList<>();
      strings.add("1");
      strings.add("2");
      strings.add("3");
      strings.add("4");
      strings.add("5");
      strings.add("6");
      strings.add("7");
      strings.add("8");
      strings.add("9");
      task(threadPoolExecutor, string -> print(string), strings);
   }

   public static void task(ThreadPoolExecutor threadPoolExecutor, Consumer<String> consume, List<String> data) {
      ArrayList<Future<Object>> objects = new ArrayList<>(data.size());
      for (String s : data) {
         Future<Object> future = threadPoolExecutor.submit(() -> consume.accept(s), null);
         objects.add(future);
      }
      for (Future<Object> futrue : objects) {
         try {
            futrue.get();
         } catch (InterruptedException e) {
            System.out.println(e.getMessage());
            Thread.currentThread().interrupt();
         } catch (ExecutionException e) {
            System.out.println(e.getMessage());
         }
      }


   }
   public static void print(String s) {
      System.out.println(s);
   }
}

ThreadPoolExecutor的使用

这里写目录标题

为什么要使用线程池？

线程池参数

代码具体实现