ThreadPoolExecutor的使用

为什么要使用线程池？

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

【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
说明:线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问
题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这
样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明:Executors 返回的线程池对象的弊端如下:

FixedThreadPool 和 SingleThreadPool : 允许的请求队列长度为
Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。 CachedThreadPool: 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

线程池参数

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

int corePoolSize, 线程池核心线程池大小

int maximumPoolSize, 线程池最大线程数量

long keepAliveTime, 空闲线程存活时间

TimeUnit unit, 空闲线程存活时间单位

BlockingQueue<Runnable> workQueue,

JDK中提供四种工作队列

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

RejectedExecutionHandler handler 拒绝策略

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);
   }
}