线程池详解

Java中预定义的线程池：

• FixedThreadPool  创建固定线程数量的线程池，适用于负载较重的服务器，使用了无界队列。

     /**
       * Creates a thread pool that reuses a fixed number of threads
       * operating off a shared unbounded queue, using the provided
       * ThreadFactory to create new threads when needed.  At any point,
       * at most {@code nThreads} threads will be active processing
       * tasks.  If additional tasks are submitted when all threads are
       * active, they will wait in the queue until a thread is
       * available.  If any thread terminates due to a failure during
       * execution prior to shutdown, a new one will take its place if
       * needed to execute subsequent tasks.  The threads in the pool will
       * exist until it is explicitly {@link ExecutorService#shutdown
       * shutdown}.
       *
       * @param nThreads the number of threads in the pool
       * @param threadFactory the factory to use when creating new threads
       * @return the newly created thread pool
       * @throws NullPointerException if threadFactory is null
       * @throws IllegalArgumentException if {@code nThreads <= 0}
       */
      public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
          return new ThreadPoolExecutor(nThreads, nThreads,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>(),
                                        threadFactory);
      }

   

• SingleThreadExecutor  创建单个线程，需要顺序保证执行任务，不会有多个线程活动，使用了无界队列。

  
      /**
       * Creates an Executor that uses a single worker thread operating
       * off an unbounded queue, and uses the provided ThreadFactory to
       * create a new thread when needed. Unlike the otherwise
       * equivalent {@code newFixedThreadPool(1, threadFactory)} the
       * returned executor is guaranteed not to be reconfigurable to use
       * additional threads.
       *
       * @param threadFactory the factory to use when creating new
       * threads
       *
       * @return the newly created single-threaded Executor
       * @throws NullPointerException if threadFactory is null
       */
      public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
          return new FinalizableDelegatedExecutorService
              (new ThreadPoolExecutor(1, 1,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory));
      }

   

CachedThreadPool  会根据需要来创建新线程的，执行很多短期异步任务的程序。

/**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to {@code execute} will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

 

• WorkStealigPool   基于ForkJoinPool实现（JDK1.7以后实现的）

      /**
       * Creates a thread pool that maintains enough threads to support
       * the given parallelism level, and may use multiple queues to
       * reduce contention. The parallelism level corresponds to the
       * maximum number of threads actively engaged in, or available to
       * engage in, task processing. The actual number of threads may
       * grow and shrink dynamically. A work-stealing pool makes no
       * guarantees about the order in which submitted tasks are
       * executed.
       *
       * @param parallelism the targeted parallelism level
       * @return the newly created thread pool
       * @throws IllegalArgumentException if {@code parallelism <= 0}
       * @since 1.8
       */
      public static ExecutorService newWorkStealingPool(int parallelism) {
          return new ForkJoinPool
              (parallelism,
               ForkJoinPool.defaultForkJoinWorkerThreadFactory,
               null, true);
      }

   

• ScheduledThreadPoolExecutor  需要定期执行周期任务，相同的工具还有Timer（不建议使用）   

     /**
       * Creates an Executor that uses a single worker thread operating
       * off an unbounded queue. (Note however that if this single
       * thread terminates due to a failure during execution prior to
       * shutdown, a new one will take its place if needed to execute
       * subsequent tasks.)  Tasks are guaranteed to execute
       * sequentially, and no more than one task will be active at any
       * given time. Unlike the otherwise equivalent
       * {@code newFixedThreadPool(1)} the returned executor is
       * guaranteed not to be reconfigurable to use additional threads.
       *
       * @return the newly created single-threaded Executor
       */
      public static ExecutorService newSingleThreadExecutor() {
          return new FinalizableDelegatedExecutorService
              (new ThreadPoolExecutor(1, 1,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>()));
      }

• Executors类下的 newSingleThreadExecutor() 方法，只包含一个线程，只需要单个线程执行周期任务，保证顺序的执行各个任务
• newScheduledThreadPool 可以包含多个线程，线程执行周期任务，适度控制后台线程数量
• 建议提交给ScheduleThreadPoolExecutor 的任务要捕获异常
• Executor框架一览图：
•