Executors工具类

Executors工具类阅读笔记

一、简介

用于创建线程池、包装成Callable线程、创建默认线程工厂的工具类

二、源码分析

主要方法

1、创建线程池相关函数-总览

• newFixedThreadPool：创建一个固定大小的线程池
• newWorkStealingPool：创建一个固定大小的携程线程池
• newWorkStealingPool：创建一个默认大小携程池，根据系统内核来默认大小
• newFixedThreadPool：创建一个固定大小线程池，可自己选择线程工厂
• newSingleThreadExecutor：创建只有一个线程的线程池
• newSingleThreadExecutor：创建只有一个线程的线程池，可自己选择线程工厂
• newCachedThreadPool：创建一个可缓存线程池，如果池长度需要可灵活回收空闲线程
• newCachedThreadPool：创建一个可缓存线程池，如果池长度需要可灵活回收空闲线程，可自定义线程工厂
• newSingleThreadScheduledExecutor：创建一个线程的线程池，执行定时及周期性任务执行
• newSingleThreadScheduledExecutor:
  • ​ 创建一个线程的线程池，执行定时及周期性任务执行。可自定义线程工厂
• newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。
• newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。 可自定义线程工厂
• unconfigurableExecutorService：把ExecutorService包装成DelegatedExecutorService
• unconfigurableScheduledExecutorService：
  • ​ 把ScheduledExecutorService包装成DelegatedScheduledExecutorService

1.1、创建线程池相关函数-解析

• 固定大小的线程池，核心线程数量和最大线程数量是一样，所以只有核心线程nTHreads个

  public static ExecutorService newFixedThreadPool(int nThreads) {
      return new ThreadPoolExecutor(nThreads, nThreads,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>());
  }
  

• 创建一个携程线程池（java的携程：用户线程和核心线程的多对多模型）

  public static ExecutorService newWorkStealingPool(int parallelism) {
      return new ForkJoinPool
          (parallelism,
           ForkJoinPool.defaultForkJoinWorkerThreadFactory,
           null, true);d
  }
  

• 创建一个根据自身核心数来创建携程池

  public static ExecutorService newWorkStealingPool() {
      return new ForkJoinPool
          (Runtime.getRuntime().availableProcessors(),
           ForkJoinPool.defaultForkJoinWorkerThreadFactory,
           null, true);
  }
  

• 创建一个固定大小线程池，可自己选择线程工厂

  public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
      return new ThreadPoolExecutor(nThreads, nThreads,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory);
  }
  

• 创建一个只有一个线程的线程池

  public static ExecutorService newSingleThreadExecutor() {
      return new FinalizableDelegatedExecutorService
          (new ThreadPoolExecutor(1, 1,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>()));
  }
  

• 创建一个只有一个线程的线程池，可自己选择线程工厂

  public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
      return new FinalizableDelegatedExecutorService
          (new ThreadPoolExecutor(1, 1,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory));
  }
  

• 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

  public static ExecutorService newCachedThreadPool() {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>());
  }
  

• 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 且可以自定义创建线程工厂

  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>(),
                                    threadFactory);
  }
  

• 创建一个线程的线程池，执行定时及周期性任务执行

  public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
      return new DelegatedScheduledExecutorService
          (new ScheduledThreadPoolExecutor(1));
  }
  

• 创建一个线程的线程池，执行定时及周期性任务执行，可自定义线程工厂

  public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
      return new DelegatedScheduledExecutorService
          (new ScheduledThreadPoolExecutor(1, threadFactory));
  }
  

• 创建一个定长线程池，支持定时及周期性任务执行。

  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
      return new ScheduledThreadPoolExecutor(corePoolSize);
  }
  

• 创建一个定长线程池，支持定时及周期性任务执行。 可自定义线程工厂

      public static ScheduledExecutorService newScheduledThreadPool(
              int corePoolSize, ThreadFactory threadFactory) {
          return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
      }
  
  

• 把ExecutorService包装成DelegatedExecutorService

  public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
      if (executor == null)
          throw new NullPointerException();
      return new DelegatedExecutorService(executor);
  } 
  

• 把ScheduledExecutorService包装成DelegatedScheduledExecutorService

  public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
      if (executor == null)
          throw new NullPointerException();
      return new DelegatedScheduledExecutorService(executor);
  }
  

2、创建线程工厂-总览

• defaultThreadFactory：创建默认工厂
• privilegedThreadFactory：创建带权限的工厂

2.1、创建线程工厂-详解

• defaultThreadFactory创建一个默认的线程工厂

  public static ThreadFactory defaultThreadFactory() {
      return new DefaultThreadFactory();
  }
  

• privilegedThreadFactory创建一个具有权限限制的线程工厂

  public static ThreadFactory privilegedThreadFactory() {
      return new PrivilegedThreadFactory();
  }
  

3、转化任意线程为Callable线程-总览

• callable(Runnable, T)：
  • 把Runnable包装成Callable类型，并把返回结果放入T中
• callable(Runnable)：
  • 把Runnable包装成Callable类型
• callable(PrivilegedAction<?>)：
  • -把PrivilegedAction包装成Callable类型
• callable(PrivilegedExceptionAction<?>):
  • 把PrivilegedExceptionAction 包装成Callable类型
• privilegedCallable(Callable)：
  • 把Callable包装成privilegedCallable(Callable实现类)
• privilegedCallableUsingCurrentClassLoader(Callable)：
  • 把Callable包装成PrivilegedCallableUsingCurrentClassLoader(Callable实现类)

3.1、转化任意线程为Callable线程-详解

• 把Runnable包装成Callable类型，并把返回结果放入T中

  public static <T> Callable<T> callable(Runnable task, T result) {
      if (task == null)
          throw new NullPointerException();
      // RunnableAdapter 是Callable的实现类
      return new RunnableAdapter<T>(task, result);
  }
  

• 根据传入的线程，生成一个Callable的装饰子类

      public static Callable<Object> callable(Runnable task) {
          if (task == null)
              throw new NullPointerException();
          return new RunnableAdapter<Object>(task, null);
      }
  

• 把PrivilegedAction包装成Callable类型

  public static Callable<Object> callable(final PrivilegedAction<?> action) {
      if (action == null)
          throw new NullPointerException();
      return new Callable<Object>() {
          public Object call() { return action.run(); }};
  }
  

• 把PrivilegedExceptionAction 包装成Callable类型

  public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
      if (action == null)
          throw new NullPointerException();
      return new Callable<Object>() {
          public Object call() throws Exception { return action.run(); }};
  }
  

• 把Callable包装成privilegedCallable(Callable实现类)

  public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
      if (callable == null)
          throw new NullPointerException();
      return new PrivilegedCallable<T>(callable);
  }
  

• 把Callable包装成PrivilegedCallableUsingCurrentClassLoader(Callable实现类)

  public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
      if (callable == null)
          throw new NullPointerException();
      return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
  }
  

三、总结

纯工具类