一、创建线程池的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){
//主线程陷入死循环，来观察结果，否则是看不到结果的
}
}
}
···