【Java 线程池】【一】线程池介绍和基本使用

public class ThreadPoolTest {

    public static ExecutorService createThreadPool() {
        // 创建一个线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                // 核心线程数设置为2
                2,
                // 最大线程数设置为5
                5,
                // 当线程池中的线程数量大于2，这多出的线程在没有任务执行的最大空闲时间，60
                60,
                // 空闲时间的单位，这里设置秒
                TimeUnit.SECONDS,
                // 线程池的阻塞队列使用LinkedBlockingQueue无界阻塞队列
                new LinkedBlockingQueue(),
                // 创建线程的线程工厂，这里test-pool是设置这个线程池的名字
                new DefaultThreadFactory("test-pool"),
                // 当任务太多，线程池线程不足、阻塞队列满时候采取什么拒绝策略
                new ThreadPoolExecutor.CallerRunsPolicy()

        );
        // 返回创建的线程池
        return executor;
    }
    static class DefaultThreadFactory implements ThreadFactory {
        private String name;
        private final AtomicInteger nextId = new AtomicInteger();
        DefaultThreadFactory(String name) {
            this.name = name;
        }
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(null, r, name + "-" + nextId.incrementAndGet());
        }
    }

    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executor = createThreadPool();
        for (int i = 0; i < 1000; i++) {
           final int num = i;
           // 封装任务，每个任务就是打印自己是当前第几个号
           Runnable task = () -> {
               System.out.println(num);
           };
           // 往线程池提交任务
           executor.execute(task);
       }
    }
}

public class ScheduledThreadPoolTest {
    // 创建一个调度线程池
    public static ScheduledExecutorService createThreadPool() {
        ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(
                // 线程池的核心线程数，配置为3
                3,
                // 创建线程的工厂，test-schedule-pool为线程池的名称
                new DefaultThreadFactory("test-schedule-pool"),
                // 任务拒绝策略，线程资源不足的时候，策略是“使用调用线程池的线程来执行”
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
        return executor;
    }

    static class DefaultThreadFactory implements ThreadFactory {
        private String name;
        private final AtomicInteger nextId = new AtomicInteger();
        DefaultThreadFactory(String name) {
            this.name = name;
        }
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(null, r, name + "-" + nextId.incrementAndGet());
        }
    }


    public static void main(String[] args) {
        // 获取调度线程池
        ScheduledExecutorService executor = createThreadPool();
        // 打印当前时间
        System.out.println("当前时间:" + new Date());
        // 立即执行的任务
        Runnable nowTask = () -> {
            System.out.println("当前时间:" + new Date() + "------执行【立即】任务");
        };
        // 延迟执行的任务
        Runnable delayTask = () -> {
            System.out.println("当前时间:" + new Date() + "------执行【延迟】任务");
        };
        // 周期性执行的任务
        Runnable periodTask = () -> {
            System.out.println("当前时间:" + new Date() + "------执行【周期性】任务");
        };

        // 提交立即任务，有线程空闲立即执行
        executor.execute(nowTask);
        // 提交一次性延迟任务，延迟2秒执行
        executor.schedule(delayTask, 2, TimeUnit.SECONDS);
        // 提交周期性的延迟任务，10秒后每3秒执行一次
        executor.scheduleWithFixedDelay(periodTask, 10, 3, TimeUnit.SECONDS);
    }
}

public class ExecutorsTest {
    public static void main(String[] args) {
        // 创建一个缓存型的线程池，这种线程池每来一个任务就会创建一个线程来执行
        Executors.newCachedThreadPool();
        // 创建一个固定线程数量的线程池
        Executors.newFixedThreadPool(3);
        // 创建一个单线程的线程池
        Executors.newSingleThreadExecutor();
        // 创建一个单线程的调度线程池
        Executors.newSingleThreadScheduledExecutor();
        // 创建一个固定线程数量的调度线程池
        Executors.newScheduledThreadPool(3);
    }
}