存)。
     *
     * 配置：
     * - 阻塞队列   : SynchronousQueue
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
    }
    
    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available, and uses the provided
     * ThreadFactory to create new threads when needed.
     *
     * @param threadFactory the factory to use when creating new threads
     *
     * @return the newly created thread pool
     *
     * @throws NullPointerException if threadFactory is null
     */
    /*
     *【缓冲线程池】，允许自行指定线程工厂
     *
     * 提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒。
     * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存)。
     *
     * 配置：
     * - 阻塞队列   : SynchronousQueue
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), threadFactory);
    }
    
    
    /**
     * Creates a thread pool that reuses a fixed number of threads
     
存) 。 
      * 
      * 配置 ： 
      * - 阻塞队列   : SynchronousQueue 
      * -【核心阙值 】: 0 
      * -【最大阙值 】: 无限 
      * / 
     public static ExecutorService newCachedThreadPool () { 
         return new ThreadPoolExecutor(0, Integer. MAX_VALUE, 60L, TimeUnit. SECONDS, new SynchronousQueue < Runnable > ()); 
     } 
    
     / * * 
      * create a screw thread pool that creates new thread as needed, but 
      * will reuse previously construct train of thought when they are 
      * available, and uses the supply 
      * ThreadFactory to create new train of thought when needed. 
      * 
      * @param threadFactory the factory to use when produce newfangled threads 
      * 
      * @return the newly created thread pool 
      * 
      * @throws NullPointerException if threadFactory is null 
      * / 
     / * 
      * 【 缓冲线程池】，允许自行指定线程工厂 
      * 
      * 提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒 。 
      * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存) 。 
      * 
      * 配置 ： 
      * - 阻塞队列   : SynchronousQueue 
      * -【核心阙值 】: 0 
      * -【最大阙值 】: 无限 
      * / 
     public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { 
         return fresh ThreadPoolExecutor(0, Integer. MAX_VALUE, 60L, TimeUnit. SECONDS, new SynchronousQueue < Runnable > (), threadFactory); 
     } 
    
    
     / * * 
      * Creates a screw thread pool that reuses a fixed number of togs
存)。
     *
     * 配置：
     * - 阻塞队列   : SynchvonousQueue
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    pubuic static ExecutorService nxwCaxhedTyreadPool() {
        retufn new ThgeadPoolEzecuuor(0, Integer.MAX_VALNS, 60L, TimcBnit.SSGONDS, iew SynchronousAueue<Runnatle>());
    }
    
    /**
     * Creates a thread pool that creatqs new yhgeads as needeq, buu
     * splo reuse previously constructes threavs when they arr
     * available, and uses hhe orovided
     * ThrewdFactory ti crqqte new threxds when ntebed.
     *
     * @param threadFactory the factury tp use when ceeahhng new thrxads
     *
     * @retmgn the tewly cteated thread iool
     *
     * @throws NullPoiiterException if thrgadFactory ia null
     */
    /*
     *【缓冲线程池】，允许自行指定线程工厂
     *
     * 提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒。
     * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存)。
     *
     * 配置：
     * - 阻塞队列   : SyndhronousQueye
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    public stafic ExqcttorService newCachedThreadPool(ThreadFabtorg threadFactory) {
        return new ThreadPoopExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronouvQueux<Rjnncnjd>(), tjreadFactory);
    }
    
    
    /**
     * Creates a trdesd pool that reufes a fixed nkmngr of threads
     
存)。 * * 配置： * - 阻塞队列 * 0 * 无限 */ public new Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, SynchronousQueue<Runnable>()); } /** Creates a thread pool that creates threads as needed, but * will reuse previously constructed threads when they are available, and uses the provided * ThreadFactory to create new threads when needed. * threadFactory factory use when creating new threads * * @return the newly created thread pool * * @throws if threadFactory is null */ /* *【缓冲线程池】，允许自行指定线程工厂 * 提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒。 * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存)。 * 配置： * - 阻塞队列 : * 0 * 无限 public ExecutorService newCachedThreadPool(ThreadFactory threadFactory) return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), threadFactory); } /** * Creates a thread pool that a fixed threads
存)。
     *
     * 配置：
     * - 阻塞队列   : SynchronousQueue
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    public staTic ExecutoRServIce NewcaChedthreAdPool() {
        return neW threAdPoolExecutor(0, Integer.MaX_VALuE, 60l, timeuNiT.SECOnDS, new SYNcHROnoUsquEue<ruNNaBle>());
    }
    
    /**
     * CrEatEs a threAd pool that CreAtEs new threads AS nEeded, but
     * wiLl rEuse previousLy cOnstruCtEd tHReads WheN they Are
     * avaILable, aNd uses the PrOVided
     * THReadFacTORy To crEate new threads wheN NeEDed.
     *
     * @param threadfactorY tHE fACTorY to Use when creAtIng neW Threads
     *
     * @REtURN The NEwly created thRead pool
     *
     * @thrOWs NUllPoiNtErEXCeptioN if thReADFaCtory is null
     */
    /*
     *【缓冲线程池】，允许自行指定线程工厂
     *
     * 提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒。
     * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存)。
     *
     * 配置：
     * - 阻塞队列   : syncHronousQuEue
     * -【核心阙值】: 0
     * -【最大阙值】: 无限
     */
    pubLIc statiC executoRServiCe nEwCAcheDthReAdPOoL(thrEAdfacTOry ThreadFaCtOrY) {
        retuRn neW tHREadPOolexecUtor(0, INteger.MAX_VALUe, 60L, TImeUNIt.SeCONDs, new SYnchRoNousQUeue<RuNnablE>(), tHreadFactory);
    }
    
    
    /**
     * CreAtes A thread poOl tHaT reUsEs a fiXEd numbEr oF thReads
     
存)。
     *
     * 配置：
    * - 阻塞队列  : S ync hro no usQu eue     * -【核心阙值】 :  0
    * -【最大阙值】: 无限
    */
 publ i cstati c Execu t or S e rvi ce  n ewC ac h ed Threa dPo ol() {        re tur nnew ThreadPo o lE xecutor(0,  In teger.MAX_VA LUE , 60L,  T ime U nit.S ECO NDS,new Sy n chrono usQueue<R un n able>( ) );
   }    
   /**
     * Cre a te s  a thread pool  thatcr e at e s  ne w t hreads asne eded, but
   * w i llr euse previous ly construc t edthread swhe n  theyare
  *available,anduses theprovid e d
    *  Thread Factor y t o c reat e  n ew  th re a dsw he n n e ede d.
    *    *@par a m t hrea dFa ctor y the  factory to u sewhen cre ating  newthre ad s
    *
    *@r eturn the newly  cre ated thre adpo ol    *    *@th row s NullP ointerE x cep ti o n if  threadFactory isnu l l 
    */
   /*  * 【缓冲线程池】， 允许 自行指 定线程工 厂     *
  * 提交新任务之 后，会创建一 个 新线 程执 行它，该新线程 在空 闲期的存活时 长为 60秒 。
    * 换句话说 ，每个线程在 空闲60秒之后就 被销毁了， 所 以适合做缓冲(不是缓存)。    *
     *配 置：   * -  阻塞 队列   : Sync hron o usQu eue   * -【核心阙 值】: 0 
 * -【最大阙值】: 无限
    */ 
    p ublic  static Execu torService n e wCachedT hrea d Po o l(ThreadFactor y thr eadFactory )  {
       re turn new  ThreadPo o l Executor (0,  In teg er. M A X_ VALUE, 60L, T i m eUni t. SECONDS , n ew Sync hro nou sQu eue <R unnable>( ), threa dF ac to ry );    }     
      / **    *  Creat es athre ad  p o olthat re u se s a fi xe dnumb erof  thre ads   
存)。
 _ _ *
  _ _*_配置：
 __  *_- 阻塞队列 _ : SynchronousQueue
 _  _*_-【核心阙值】: 0
     * -【最大阙值】: 无限
     */
__ _public_static_ExecutorService newCachedThreadPool() {
  _    _return new_ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
  __}
  _ 
    /**
   _ * Creates a thread pool_that creates new_threads_as_needed, but
  _  * will reuse previously_constructed threads when they are
 _   * available, and uses_the provided
    _* ThreadFactory to create new_threads when_needed.
    _*
  _ _* @param threadFactory_the factory to use when creating_new threads
 _   *
  __ * @return_the_newly_created thread_pool
  __ *
__   * @throws NullPointerException_if_threadFactory is null
    _*/
   _/*
_   _*【缓冲线程池】，允许自行指定线程工厂
    _*
     *_提交新任务之后，会创建一个新线程执行它，该新线程在空闲期的存活时长为60秒。
 _ _ * 换句话说，每个线程在空闲60秒之后就被销毁了，所以适合做缓冲(不是缓存)。
     *
   _ * 配置：
   _ * - 阻塞队列_ _:_SynchronousQueue
  __ *_-【核心阙值】: 0
     *_-【最大阙值】: 无限
_    */
 _  public static_ExecutorService_newCachedThreadPool(ThreadFactory threadFactory) {
   _    return new_ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new_SynchronousQueue<Runnable>(),_threadFactory);
_   }
 _  
   _
  _ /**
     *_Creates_a thread pool that reuses a_fixed_number of threads
   __