几种常见的线程池：

Java通过Executors提供四种线程池，分别为：

• newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

• newFixedThreadPool

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

• newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。

• newSingleThreadExecutor

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

 

newFixedThreadPool

//定长线程池
        ExecutorService threadPoolService = Executors.newFixedThreadPool(10);
        threadPoolService.execute(new Runnable() {
            @Override
            public void run() {
                Thread thread = Thread.currentThread();
                String name = thread.getName();
                System.out.println(name);
            }
        });

newScheduledThreadPool

        /**
         * 可支持定时任务的线程池
         *      下面的例子表示任务再3分钟后执行
         */
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(100);
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("test");
            }
        },3L,TimeUnit.MINUTES);

newSingleThreadExecutor

        /**
         * 创建单线程化的线程池，他只会用唯一的工作线程来执行任务，保证所有的任务按照顺序来执行。
         */
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index=i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("testing..... index: "+index);
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

newCachedThreadPool

        /**
         * 可缓存的线程池
         *      查看源码发现是，再我们使用完后，线程不会立刻销毁，先缓存起来过了活跃时间后才销毁
         */
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("test...");
            }
        });

ThreadPoolExecutor ：

在Java开发规范中，写到这些线程的默认值过大，一般采用的是底层的线程池[ ThreadPoolExecutor ]，来自己创建线程池，如下：

ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 100, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("testing...");
            }
        });