Java中的线程池ExecutorService

示例

    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);
        }  

    }  

CachedThreadPool

CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来。会终止并且从缓存中移除已有60秒未被使用的线程。

如果线程有可用的，就使用之前创建好的线程，

如果线程没有可用的，就新创建线程。

• 重用：缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse；如果没有，就建一个新的线程加入池中
• 使用场景：缓存型池子通常用于执行一些生存期很短的异步型任务，因此在一些面向连接的daemon型SERVER中用得不多。
• 超时：能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s，超过这个IDLE时长，线程实例将被终止及移出池。
• 结束：注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。

    // 线程池的大小会根据执行的任务数动态分配
    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次执行

创建了一个固定大小的线程池，容量为3，然后循环执行了4个任务。由输出结果可以看到，前3个任务首先执行完，然后空闲下来的线程去执行第4个任务。

SingleThreadExecutor

SingleThreadExecutor得到的是一个单个的线程，这个线程会保证你的任务执行完成。

如果当前线程意外终止，会创建一个新线程继续执行任务，这和我们直接创建线程不同，也和newFixedThreadPool(1)不同。

    // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务
    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次执行

4个任务是顺序执行的。

ScheduledThreadPool

ScheduledThreadPool是一个固定大小的线程池，与FixedThreadPool类似，执行的任务是定时执行。

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次执行

——与FixedThreadPool的区别？

线程池