四种最常见的线程池代码示例

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

/**
 * 线程池
 * newCachedTheadPool 可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，则新建线程
 * newFixedThreadPool 定长线程池，可以控制线程最大并发数，超出的线程会在队列中等待
 * newScheduledThreadedPool 定长线程池，支持定时及周期性任务
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行（FIFO，LIFO）
 */
public class PoolTest1 {


    public static void main(String[] args) throws InterruptedException {
        // 可缓存线程池
//        createCacheThread();
        // 定长线程池
//        createFixedThread();
        //  周期线程池
//        createScheduleThread();
        // 单线程线程池
        createSingleThread();
    }

    /**
     * 可缓存线程池
     * 如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     *
     * @throws InterruptedException
     */

    public static void createCacheThread() throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "， temp: " + temp);
                }
            });
            // 如果加上sleep，可以更清晰地看到线程池将线程复用了
//            Thread.sleep(1);
        }
    }

    /**
     * 定长线程池
     * 可以控制线程的长度，控制线程的最大并发数，超出的线程会在队列中等待
     */
    public static void createFixedThread() {
        // 可固定长度线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 20; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ", " + temp);
                }
            });
        }
    }

    /**
     * 周期线程池
     * 可以调用schedule方法，来执行延迟线程
     * 可以调用scheduleAtFixedRate方法来实现周期性执行线程
     *
     * @throws InterruptedException
     */
    private static void createScheduleThread() throws InterruptedException {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 20; i++) {
            Thread.sleep(50);
            final int temp = i;
            // 延迟3秒后执行
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "， " + temp);
                }
                // 3秒后执行
            }, 3, TimeUnit.SECONDS);

            // 每2秒执行一次
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "， " + temp);
                }
                // 3秒后执行
            }, 2,3, TimeUnit.SECONDS);
        }
    }


    /**
     * 创建单个工作线程的线程池
     * 1、shutdown() 和 shutdownNow() 的区别
     * shutdown() 只是关闭了提交通道，用submit()是无效的；而内部该怎么跑还是怎么跑，跑完再停。
     * shutdownNow() 能立即停止线程池，正在跑的和正在等待的任务都停下了。
     *
     * 2、shutdown() 和 awaitTermination() 的区别
     * shutdown() 后，不能再提交新的任务进去；但是 awaitTermination() 后，可以继续提交。
     *
     * awaitTermination()是阻塞的，返回结果是线程池是否已停止（true/false）；shutdown() 不阻塞。
     */
    private static void createSingleThread() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            // 可执行线程execute方法表示启动线程
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ", " + temp);
                }
            });
        }
        executorService.shutdown();
    }
}

上面的方法通过修改main中的注释可以直接运行，代码已亲测没有问题。