Java中 ExecutorService四种线程池简单说明

package com.leitan.architect.threads.threadpool;

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

/**
 * @Author: lei.tan
 * @Date: 2018-11-14 15:05
 */
public class ThreadPoolTest {

    /**
     * CachedThreadPool
     * 创建一个可缓存线程池，如果线程池数量超过处理需要，可自动回收空闲线程，如果无可回收线程则新建线程
     */
    public static void cachedThreadPoolTest() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 200);// 如果不延迟可能出现多个线程
            } catch (Exception e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + ": " + index));
            if (i == 9) cachedThreadPool.shutdown();
        }
    }

    /**
     * FixedThreadPool
     * 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
     */
    public static void fixedThreadPoolTest() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ": " + index);
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            if (i == 9) fixedThreadPool.shutdown();
        }
    }

    /**
     * ScheduledThreadPool
     * 创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
     */
    public static void scheduleThreadPoolTest1() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        scheduledThreadPool.schedule(() -> System.out.println(Thread.currentThread().getName() + ": 延迟了3秒，我开始做事...."), 3, TimeUnit.SECONDS);
        for (int i = 1; i <= 3; i++) {
            try {
                Thread.sleep(1000 - 10);
                System.out.println("第" + i + "秒...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * ScheduledThreadPool
     * 创建一个定长线程池，支持定时及周期性任务执行。周期执行示例代码如下：
     */
    public static void scheduleThreadPoolTest2() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        // 表示延迟1秒后每3秒执行一次。 ScheduledExecutorService比Timer更安全，功能更强大
        scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println(Thread.currentThread().getName() + ": delay 1 seconds, and excute every 3 seconds"), 1, 3, TimeUnit.SECONDS);
    }

    /**
     * SingleThreadExecutor
     * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
     */
    public static void singleThreadExecutorTest() {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ": " + index);
                    Thread.sleep(2000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    }


    public static void main(String[] args) {
        // CachedThreadPool
        // 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
//        cachedThreadPoolTest();

        // FixedThreadPool
        // 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
        fixedThreadPoolTest();


        // ScheduledThreadPool
        // 创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
//        scheduleThreadPoolTest1();

        // ScheduledThreadPool
        // 创建一个定长线程池，支持定时及周期性任务执行。周期执行示例代码如下：
//        scheduleThreadPoolTest2();

        // SingleThreadExecutor
        // 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
//        singleThreadExecutorTest();

    }

}