java四种线程池的使用及说明

通过Executors的静态方法返回四种线程池的实例对象：

import java.util.concurrent.*;

/**
 * java四种线程池的使用实现
 */
public class Pool {

    public static void main(String[] args) throws InterruptedException {

        /*
        由Executors的newCachedThreadPool方法创建，不存在核心线程，只存在数量不定的非核心线程，
        而且其数量最大值为Integer.MAX_VALUE。当线程池中的线程都处于活动时(全满),
        线程池会创建新的线程来处理新的任务，否则就会利用新的线程来处理新的任务，
        线程池中的空闲线程都有超时机制，默认超时时长为60s，超过60s的空闲线程就会被回收。
        和FixedThreadPool不同的是，CachedThreadPool的任务队列其实相当于一个空的集合，
        这将导致任何任务都会被执行，因为在这种场景下SynchronousQueue是不能插入任务的，
        SynchronousQueue是一个特殊的队列，在很多情况下可以理解为一个无法储存元素的队列。
        从CachedThreadPool的特性看，这类线程比较适合执行大量耗时较小的任务。
        当整个线程池都处于闲置状态时，线程池中的线程都会因为超时而被停止回收，几乎是不占任何系统资源。
         */
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            final int index = i;

            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "  " + index);
                }
            });
        }

        /*
        由Executors的newFixedThreadPool方法创建。它是一种线程数量固定的线程池，当线程处于空闲状态时，
        他们并不会被回收，除非线程池被关闭。当所有的线程都处于活动状态时，新的任务都会处于等待状态，
        直到有线程空闲出来。FixedThreadPool只有核心线程，且该核心线程都不会被回收，这意味着它可以更快地响应外界的请求。
        FixedThreadPool没有额外线程，只存在核心线程，而且核心线程没有超时机制，而且任务队列没有长度的限制。
         */
        ExecutorService executorService1 = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            final int index = i;

            executorService1.execute(() -> {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + index);
            });
        }

        /*
        通过Executors的newScheduledThreadPool方式创建，核心线程数量是固定的，而非核心线程是没有限制的，
        并且当非核心线程闲置时它会被立即回收，
        ScheduledThreadPool这类线程池主要用于执行定时任务和具有固定时期的重复任务。
         */
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);

        scheduledExecutorService.schedule(() -> {
            System.out.println("延迟三秒");
        }, 3, TimeUnit.SECONDS);

        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("延迟一秒后，每三秒执行一次");
        }, 1, 3, TimeUnit.SECONDS);

        /*
        通过Executors的newSingleThreadExecutor方法来创建。这类线程池内部只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行。
        SingleThreadExecutor的意义在于统一所有外界任务一个线程中，这使得这些任务之间不需要处理线程同步的问题
         */

        ExecutorService executorService2 = Executors.newSingleThreadExecutor();
        executorService2.execute(() -> System.out.println("newSingleThreadExecutor"));
    }
}