一、创建线程池的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){

//主线程陷入死循环，来观察结果，否则是看不到结果的

}

}

}

···