import java.util.concurrent.ExecutorService;      import java.util.concurrent.Executors;      import java.util.concurrent.ScheduledExecutorService;            public class Ch09_Executor {                   private static void run(ExecutorService threadPool) {          for(int i = 1; i < 5; i++) {                    final int taskID = i;                    threadPool.execute(new Runnable() {                        @Override              public void run() {                            for(int i = 1; i < 5; i++) {                                try {                                    Thread.sleep(20);// 为了测试出效果，让每次任务执行都需要一定时间                                } catch (InterruptedException e) {                                    e.printStackTrace();                                }                                System.out.println("第" + taskID + "次任务的第" + i + "次执行");                            }                        }                    });                }                threadPool.shutdown();// 任务执行完毕，关闭线程池           }                    public static void main(String[] args) {              // 创建可以容纳3个线程的线程池              ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);                            // 线程池的大小会根据执行的任务数动态分配              ExecutorService cachedThreadPool = Executors.newCachedThreadPool();                                // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务                ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();                            // 效果类似于Timer定时器              ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);                            run(fixedThreadPool);      //      run(cachedThreadPool);      //      run(singleThreadPool);      //      run(scheduledThreadPool);          }            }  

    // 线程池的大小会根据执行的任务数动态分配      ExecutorService cachedThreadPool = Executors.newCachedThreadPool();            public static ExecutorService newCachedThreadPool() {          return new ThreadPoolExecutor(0,                 //core pool size                                        Integer.MAX_VALUE, //maximum pool size                                        60L,               //keep alive time                                        TimeUnit.SECONDS,                                        new SynchronousQueue<Runnable>());      }  执行结果：    第1次任务的第1次执行      第4次任务的第1次执行      第3次任务的第1次执行      第2次任务的第1次执行      第3次任务的第2次执行      第4次任务的第2次执行      第2次任务的第2次执行      第1次任务的第2次执行      第2次任务的第3次执行      第4次任务的第3次执行      第3次任务的第3次执行      第1次任务的第3次执行      第2次任务的第4次执行      第1次任务的第4次执行      第3次任务的第4次执行      第4次任务的第4次执行  4个任务是交替执行的。FixedThreadPool在FixedThreadPool中，有一个固定大小的池。如果当前需要执行的任务超过池大小，那么多出的任务处于等待状态，直到有空闲下来的线程执行任务，如果当前需要执行的任务小于池大小，空闲的线程也不会去销毁。    重用：fixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程    固定数目：其独特之处在于，任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子    超时：和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），    使用场景：所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器    源码分析：从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同：    fixed池线程数固定，并且是0秒IDLE（无IDLE）    cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE    // 创建可以容纳3个线程的线程池      ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);            public static ExecutorService newFixedThreadPool(int nThreads) {              return new ThreadPoolExecutor(nThreads, //core pool size                                            nThreads, //maximum pool size                                            0L,       //keep alive time                                            TimeUnit.MILLISECONDS,                                            new LinkedBlockingQueue<Runnable>());      }  

1. 第1次任务的第1次执行  
2. 第3次任务的第1次执行  
3. 第2次任务的第1次执行  
4. 第3次任务的第2次执行  
5. 第2次任务的第2次执行  
6. 第1次任务的第2次执行  
7. 第3次任务的第3次执行  
8. 第1次任务的第3次执行  
9. 第2次任务的第3次执行  
10. 第3次任务的第4次执行  
11. 第1次任务的第4次执行  
12. 第2次任务的第4次执行  
13. 第4次任务的第1次执行  
14. 第4次任务的第2次执行  
15. 第4次任务的第3次执行  
16. 第4次任务的第4次执行  

    // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();            public static ExecutorService newSingleThreadExecutor() {              return new FinalizableDelegatedExecutorService                  (new ThreadPoolExecutor(1,  //core pool size                                          1,  //maximum pool size                                          0L, //keep alive time                                          TimeUnit.MILLISECONDS,                                          new LinkedBlockingQueue<Runnable>()));      }  

1. 第1次任务的第1次执行  
2. 第1次任务的第2次执行  
3. 第1次任务的第3次执行  
4. 第1次任务的第4次执行  
5. 第2次任务的第1次执行  
6. 第2次任务的第2次执行  
7. 第2次任务的第3次执行  
8. 第2次任务的第4次执行  
9. 第3次任务的第1次执行  
10. 第3次任务的第2次执行  
11. 第3次任务的第3次执行  
12. 第3次任务的第4次执行  
13. 第4次任务的第1次执行  
14. 第4次任务的第2次执行  
15. 第4次任务的第3次执行  
16. 第4次任务的第4次执行  

1. // 效果类似于Timer定时器  

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);    public ScheduledThreadPoolExecutor(int corePoolSize) {          super(corePoolSize,      //core pool size                Integer.MAX_VALUE, //maximum pool size                0,                 //keep alive time                TimeUnit.NANOSECONDS,                new DelayedWorkQueue());  }  

1. 第1次任务的第1次执行  
2. 第2次任务的第1次执行  
3. 第3次任务的第1次执行  
4. 第2次任务的第2次执行  
5. 第1次任务的第2次执行  
6. 第3次任务的第2次执行  
7. 第2次任务的第3次执行  
8. 第1次任务的第3次执行  
9. 第3次任务的第3次执行  
10. 第2次任务的第4次执行  
11. 第1次任务的第4次执行  
12. 第3次任务的第4次执行  
13. 第4次任务的第1次执行  
14. 第4次任务的第2次执行  
15. 第4次任务的第3次执行  
16. 第4次任务的第4次执行