一、创建线程池的6种方式：

Executors.newCachedThreadPool();
创建一个可缓存线程池，应用中存在的线程数可以无限大
Executors.newFixedThreadPool(2)
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
Executors.newScheduledThreadPool(2)
创建一个定长线程池，支持定时及周期性任务执行。

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

5 Executors.newSingleThreadScheduledExecutor();
创建一个单例线程池，定期或延时执行任务。

6 Executors.newWorkStealingPool(3);
创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不穿如并行级别参数，将默认为当前系统的CPU个数。

二、代码

线程代码

public class ThreadForpools implements Runnable {

    private Integer index;

    public ThreadForpools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println(index + " 开始处理线程！！！");
            Thread.sleep(index * 2000);  //等2秒方便参观
            System.out.println(index + " 我的线程标识是：" + this.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

方式一：newCachedThreadPool


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

/**
 * 描述：newCachedThreadPool
 * 创建一个可缓存线程池，应用中存在的线程数可以无限大
 */
public class ThreadpoolsCached {
    public static  void main(String[]args)
    {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        
        for(int i=0;i<10;i++)
        {
            final int index=i;
            newCachedThreadPool.execute(new ThreadForpools(index));
        }
    }

}

借助jconsole工具看看线程，由下图可看。所有的线程一次性已经加载进来了。
线程执行完了，线程数也相应减少了，最后程序也就结束了。

2.jpg

方式二：newFixedThreadPool


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

/**
 * 描述：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 */
public class ThreadpoolsFixed {

    public static  void main(String[]args)
    {
        //线程池允许同时存在两个线程
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        
        for(int i=0;i<10;i++)
        {
            final int index=i;
            newFixedThreadPool.execute(new ThreadForpools(index));
        }
    }
}

再看看jconsole的线程情况。只有两个线程。线程执行完后还会处于等待的状态。

线程

方式三：newScheduledThreadPool


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

/**
 * 描述：创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下
 */
public class ThreadpoolsScheduled {
    /**
     * 我们获取四次次线程，观察4个线程地址
     * @param args
     */
    public static  void main(String[]args)
    {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);

        for(int i=0;i<10;i++)
        {
            final int index=i;
            //延迟三秒执行
            newScheduledThreadPool.schedule(new ThreadForpools(index),3, TimeUnit.SECONDS);
        }
    }

}

方式四：newSingleThreadExecutor


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

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

    public static  void main(String[]args) {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++)
        {
            final int index=i;
            newSingleThreadExecutor.execute(new ThreadForpools(index));
        }
    }
}

方式五：newSingleThreadScheduledExecutor


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

/**
 * 描述：创建一个单例线程池，定期或延时执行任务。
 */
public class ThreadpoolsSingleThreadScheduled {
    /**
     * 我们获取四次次线程，观察4个线程地址
     * @param args
     */
    public static  void main(String[]args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();


        for(int i=0;i<10;i++)
        {
            final int index=i;
            scheduledExecutorService.schedule(new ThreadForpools(index),3, TimeUnit.SECONDS);

        }
    }

}

方式六：

···

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

描述：创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，

如不穿如并行级别参数，将默认为当前系统的CPU个数。
*/
public class ThreadpoolsWorkStealingPool {
public static void main(String[] args) throws Exception {

 // 设置并行级别为2，即默认每时每刻只有2个线程同时执行
 ExecutorService executorService = Executors.newWorkStealingPool(3);

 for (int i = 1; i <= 50; i++) {
     final int count=i;
     
     executorService.submit(new ThreadForpools(count));
 }
 while(true){
     //主线程陷入死循环，来观察结果，否则是看不到结果的
 }

}

···