线程池的3个常用方式

1.为什么要用线城池，优势？

2.应用方式

package com.thread;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *Java中的线程池是通过 Executor来实现的，该框架用到了Executor，Executors,ExecutorService,ThreadPoolExecutor
 * 这几个类
 *
 *
 * 线程池的3种应用方式
 *
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {

        /**
         *
         *     public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         *
         * 主要特点：
         * 1.创建一个定长的线程池，可控制最大并发数，超出的线程会在队列中等待
         *
         * 2.newFixedThreadPool创建线程中 coolPoolSize 和 maxiMumPoolSize 值是相等的它使用的LinkedBlockQueue
         *
         */
        ExecutorService executorService = Executors.newFixedThreadPool(5); //一池5个线程处理


        /**
         *    public static ExecutorService newSingleThreadExecutor() {
         *         return new FinalizableDelegatedExecutorService
         *             (new ThreadPoolExecutor(1, 1,
         *                                     0L, TimeUnit.MILLISECONDS,
         *                                     new LinkedBlockingQueue<Runnable>()));
         *     }
         *
         *    主要特点：
         *    1.创建一个单一线程化的线程池，它只会用唯一的工作线程 来执行任务，保证所有的任务按照指定的线程来执行
         *
         *    2.newSingleThreadExecutor 中将 coolPoolSize 和 maxiMumPoolSize都设置为1 它使用的是 LinkedBlockingQueue
         */
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();//一池一个线程

        /**
         *
         *  public static ExecutorService newCachedThreadPool() {
         *         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                       60L, TimeUnit.SECONDS,
         *                                       new SynchronousQueue<Runnable>());
         *     }
         *
         *   主要特点：
         *   1.创建一个可以缓存的线程池，如果线程长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
         *   2.newCachedThreadPool 将coolPoolSize 设置成 0 将maxiMumPoolSize设置为 Integer.MAX_VALUE
         *   使用了SynchronousQueue 也就是说 来了任务就创建线程运行 当空闲60S后 就销毁线程
         *
         */
        ExecutorService executorService2 = Executors.newCachedThreadPool();//一池N个线程

        //10个用户来创办业务,每一个用户就是来自外部的请求线程
         try {
             for (int i = 1; i <=10 ; i++) {
                 executorService.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"\t 办理业务");
                 });
//                  try {
//                        TimeUnit.MILLISECONDS.sleep(200);
//                       } catch (Exception e) {
//                        e.printStackTrace();
//                    }
             }
              } catch (Exception e) {
               e.printStackTrace();
           }finally {
             executorService.shutdown();
         }


    }
}

 executorService的输出结果

 pool-1-thread-1     办理业务
pool-1-thread-3     办理业务
pool-1-thread-2     办理业务
pool-1-thread-2     办理业务
pool-1-thread-5     办理业务
pool-1-thread-3     办理业务
pool-1-thread-1     办理业务
pool-1-thread-4     办理业务
pool-1-thread-5     办理业务
pool-1-thread-2     办理业务

executorService1的输出结果

pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务

executorService2的输出结果

pool-1-thread-1     办理业务
pool-1-thread-4     办理业务
pool-1-thread-3     办理业务
pool-1-thread-2     办理业务
pool-1-thread-7     办理业务
pool-1-thread-6     办理业务
pool-1-thread-5     办理业务
pool-1-thread-8     办理业务
pool-1-thread-8     办理业务
pool-1-thread-1     办理业务