Executors提供的四种线程池

java.util.concurrent.Executors类，提供了创建四种线程池的方法：

1. **newCachedThreadPool：**用来创建一个可缓存线程池，该线程池没有长度限制，对于新的任务，如果有空闲的线程，则使用空闲的线程执行，如果没有，则新建一个线程来执行任务。如果线程池长度超过处理需要，可灵活回收空闲线程。

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

2. **newFixedThreadPool ：**用来创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

ExecutorService executorService = Executors.newFixedThreadPool(10);//线程池长度为10
// 定长线程池的大小通常根据系统资源进行设置：Runtime.getRuntime().availableProcessors()。
Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

3. **newScheduledThreadPool：**用来创建一个定长线程池，并且支持定时和周期性的执行任务

// 长度10
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
// 1.延迟三秒执行
newScheduledThreadPool.schedule(new ThreadForpools(index), 3, TimeUnit.SECONDS);
// 2.延迟10s执行，每隔5s执行一次。
newScheduledThreadPool.scheduleAtFixedRate(new ThreadForpools(0), 10, 5, TimeUnit.SECONDS);

4. **newSingleThreadExecutor：**用来创建一个单线程化的线程池，它只用唯一的工作线程来执行任务，一次只支持一个，所有任务按照指定的顺序执行。

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

// 栗子

package com.ikqq02.pooltest;

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

class ThreadForpools implements Runnable {

    private Integer index;

    public ThreadForpools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！");
            Thread.sleep(index * 100);
            System.out.println("我的线程标识是：" + this.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 1. 创建一个可缓存线程池，应用中存在的线程数可以无限大
class newCachedThreadPool {
    public static void main(String[] args) {
        //我们获取四次次线程，观察4个线程地址
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        System.out.println("*******newCachedThreadPool(可缓存线程池)********");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            newCachedThreadPool.execute(new ThreadForpools(index));
        }
    }
}

// 2. 定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
class newFixedThreadPool {
    public static void main(String[] args) {
        //线程池允许同时存在两个线程
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        System.out.println("*******newFixedThreadPool(定长线程池)***********");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            newFixedThreadPool.execute(new ThreadForpools(index));
        }
    }
}

// 3. 创建一个定长线程池，支持定时及周期性任务执行
class newScheduledThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
        System.out.println("*********newScheduledThreadPool(支持定时)*************");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            //延迟三秒执行
            newScheduledThreadPool.schedule(new ThreadForpools(index), 3, TimeUnit.SECONDS);
        }


        //周期性执行
        // 长度20
        ScheduledExecutorService newScheduledThreadPool2 = Executors.newScheduledThreadPool(20);
        // 延迟10s执行，每个5s执行一次。
        newScheduledThreadPool2.scheduleAtFixedRate(new ThreadForpools(0), 10, 5, TimeUnit.SECONDS);
    // 执行结果：延迟三秒之后执行，除了延迟执行之外和newFixedThreadPool基本相同，可以用来执行定时任务
}

// 4. 单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
class newSingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        System.out.println("********newSingleThreadExecutor(单线程化的线程池)**********");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            newSingleThreadExecutor.execute(new ThreadForpools(index));
        }
    }
}

参考：https://blog.csdn.net/caihaijiang/article/details/30812293
https://www.cnblogs.com/ljp-sun/p/6580147.html