1、ExecutorService的介绍
ExecutorService 接口继承了Executor 接口，是Executor 的子接口。
Executors类 提供工厂方法用来创建不同类型的线程池。Executors是工具类，他提供对ThreadPoolExecutor的封装，会产生几种线程池供大家使用。
关于 Executor 、ExecutorService、Executors三者的区别：
参考：Executor, ExecutorService 和 Executors 间的区别与联系 - 夏威夷8080 - 博客园
UML简要类图关系：
2、ExecutorService 的获取
注：返回值都是 ExecutorService
3种方法以及每种方法对应的一个重载的方法。
如重载方法：newCachedThreadPool(ThreadFactory threadFactory）：
ThreadFactory 也是一个接口，该接口允许我们自己去写实现类，在实现类的内部只需要创建一个线程对象即可——这样的话，相当于我们自己(程序员)可以控制线程池中每一个线程对象的创建。
上面的 “无界队列方式” —— 是指任务累加或者说缓存的时候，是不限制数量的。
（1）newCachedThreadPool() 方法、
以及其重载的方法法 newCachedThreadPool(ThreadFactory threadFactory）
：创建一个默认的线程池对象,里面的线程可重用,且在第一次使用时才创建；
重载的：线程池中的所有线程都使用ThreadFactory来创建,这样的线程无需手动启动,自动执行。
代码示例：MyTest01
package com.zhoulz.demo02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
/**
* 练习 Executors 获取ExecutorService，然后调用方法，提交任务；
* newCachedThreadPool()方法、
* 以及其重载的方法newCachedThreadPool(ThreadFactory threadFactory）
*/
public class MyTest01 {
public static void main(String[] args) {
//test1(); // 下面test1()中的内容被提取出来了—— 快捷键Shift+Alt+M:提取方法Extract Method
// 提取的原因是因为方便测试。接下来要测试newCachedThreadPool()重载的方法
test2();
}
//（1）练习newCachedThreadPool()方法
private static void test1() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newCachedThreadPool();
// 然后就可以调用方法 :如提交任务、shutdown()方法关闭提交
// 2、提交任务 —— 任务可以是Runnable类型的对象，也可以是Callable类型的对象
// 为了代码的整洁性，下面单独写了一个任务类。（也可以写一个匿名内部类）
// 可以通过循环的方式来提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable(i));
}
}
//（2）练习newCachedThreadPool()重载的方法—— （在里面直接传参数 ThreadFactory threadFactory）
private static void test2() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newCachedThreadPool(new ThreadFactory() {
int n = 1;
// 匿名内部类的内部，允许我们直接创建一个线程对象。所以下面return的时候，可以直接new
@Override
public Thread newThread(Runnable r) {
//return null;
// 直接 new，并把Runnable的对象作为一个实参
return new Thread(r,"自定义的线程名称" + n++);
// 这样，创建出来的线程 new Thread()就可以和这个任务Runnable r 绑定在一起了！！！
// 然后就可以执行了。。。
// 还可以指定线程名称、加编号 n ...见上
}
});
// 2、提交任务（这里是通过匿名内部类的方式，见上面）
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable(i));
}
}
}
/**
* 任务类：包含一个任务编号，在任务中，打印出是哪一个线程正在执行任务
*/
class MyRunnable implements Runnable{
// 为了对任务做一个区分，可以加一个编号，不能通过run()方法传进来，所以要通过构造方法
private int id;
public MyRunnable(int id) {
this.id = id;
}
@Override
public void run() {
// 获取线程的名称，打印一句话（这就是要执行的任务）
String name = Thread.currentThread().getName();
System.out.println(name + "执行了任务。。。" + id);
}
}结果：
test01：创建了10个线程
test02：—— 可见10个线程都是自定义创建的。
（2）newFixedThreadPool(int nThreads) 方法、以及其重载的方法 newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
： 创建一个可重用固定线程数的线程池 ；
重载的:创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建。
代码示例：MyTest02（基本同MyTest01）
package com.zhoulz.demo02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
/**
* 练习 Executors 获取ExecutorService，然后调用方法，提交任务；
*（2）newFixedThreadPool(int nThreads)方法、以及其重载的方法
* newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
*/
public class MyTest02 {
public static void main(String[] args) {
//test1();
test2();
}
//（1）练习newFixedThreadPool(int nThreads)方法
private static void test1() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newFixedThreadPool(3);
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable2(i));
}
}
//（2）练习newCachedThreadPool()重载的方法
private static void test2() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newFixedThreadPool(3,new ThreadFactory() {
int n = 1;
@Override
public Thread newThread(Runnable r) {
return new Thread(r,"自定义的线程名称" + n++ +"-zlz");
}
});
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable2(i));
}
}
}
/**
* 任务类：包含一个任务编号，在任务中，打印出是哪一个线程正在执行任务
*/
class MyRunnable2 implements Runnable{
private int id;
public MyRunnable2(int id) {
this.id = id;
}
@Override
public void run() {
// 获取线程的名称，打印一句话
String name = Thread.currentThread().getName();
System.out.println(name + "执行了任务。。。" + id);
}
}结果：
test01：只创建了3个线程
test02：自定义的创建了3个线程
这是匿名内部类中自定义的线程对象（任务？）加了“-zlz”作区分
结合如下输出结果，可见 执行的任务/线程是匿名内部类里的，而不是MyRunnable2里的。
但是为什么没执行呢？(下面还是提交了任务 new MyRunnable2(i) 的啊)
（3）newSingleThreadExecutor()方法、
以及其重载的方法 newSingleThreadExecutor(ThreadFactory threadFactory)
：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程；
重载的：创建一个使用单个 worker 线程的 Executor，且线程池中的所有线程都使用ThreadFactory来创建。
代码示例：MyTest03（基本同MyTest01、MyTest02）
package com.zhoulz.demo02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
/**
* 练习 Executors 获取ExecutorService，然后调用方法，提交任务；
*（3）newSingleThreadExecutor()方法、以及其重载的方法
* newSingleThreadExecutor(ThreadFactory threadFactory)
*/
public class MyTest03 {
public static void main(String[] args) {
//test1();
test2();
}
//（1）练习newFixedThreadPool(int nThreads)方法
private static void test1() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newSingleThreadExecutor();
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable3(i));
}
}
//（2）练习newCachedThreadPool()重载的方法
private static void test2() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {
int n = 1;
@Override
public Thread newThread(Runnable r) {
return new Thread(r,"自定义的线程名称" + n++ +"-zlz");
}
});
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable3(i));
}
}
}
/**
* 任务类：包含一个任务编号，在任务中，打印出是哪一个线程正在执行任务
*/
class MyRunnable3 implements Runnable{
private int id;
public MyRunnable3(int id) {
this.id = id;
}
@Override
public void run() {
// 获取线程的名称，打印一句话
String name = Thread.currentThread().getName();
System.out.println(name + "执行了任务。。。" + id);
}
}结果：
test01：只创建了1个线程
test02：自定义的只创建了1个线程
submit()方法 —— 见上面的例子。
3、shutdown()方法
以 newSingleThreadExecutor()方法、以及其重载的法 newSingleThreadExecutor(ThreadFactory threadFactory) 为例，进行举例。
代码示例：
package com.zhoulz.demo02;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
/**
* 练习 Executors 获取ExecutorService，测试关闭线程池的方法；
* （以newSingleThreadExecutor()-单线程的获取方法为例）
* 关闭线程数池的两种形式：
* 1）直接关闭；
* 2）关闭之后不再接收新的任务，以前的任务还会继续执行；
*/
public class MyTest04 {
public static void main(String[] args) {
//test1();
test2();
}
//（1）练习newFixedThreadPool(int nThreads)方法
private static void test1() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newSingleThreadExecutor();
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable4(i));
}
// 3、关闭线程池，仅仅是不再接收新的任务，以前的任务还会继续执行
es.shutdown(); // 结果：1个线程把10个任务执行完了
// 验证关闭线程池之后，还能不能再继续提交新的任务？结果：是不可以的
//es.submit(new MyRunnable4(888));
// 还有一个关闭方法 shutdownNow()—— 见test02
}
//（2）练习newCachedThreadPool()重载的方法
private static void test2() {
// 1、使用工厂类——获取线程池对象
final ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {
int n = 1;
@Override
public Thread newThread(Runnable r) {
return new Thread(r,"自定义的线程名称" + n++ +"-zlz");
}
});
// 2、提交任务
for (int i = 1; i <= 10; i++) {
es.submit(new MyRunnable4(i));
}
// 3、立刻关闭线程池，如果线程池中还有缓存的任务没有执行，则取消执行，并返回这些任务
// 返回的集合怎么保存？用List集合进行保存。shutdownNow()方法的返回值就是List
List<Runnable> list = es.shutdownNow();
// 可以对List集合进行遍历。也可以直接输出，但是前提得在任务类/线程类MyRunnable4中进行toString()方法的重写
// toString()方法重写了，但是结果还是java.util.concurrent.FutureTask@14ae5a5 ???
System.out.println(list);
// 此时，同样不能提交新的任务
}
}
/**
* 任务类：包含一个任务编号，在任务中，打印出是哪一个线程正在执行任务
*/
class MyRunnable4 implements Runnable{
private int id;
public MyRunnable4(int id) {
this.id = id;
}
@Override
public String toString() {
return "MyRunnable4{" +
"id=" + id +
'}';
}
@Override
public void run() {
// 获取线程的名称，打印一句话
String name = Thread.currentThread().getName();
System.out.println(name + "执行了任务。。。" + id);
}
}4、ExecutorService 的获取 —— 3种方法的总结
1）newCachedThreadPool()：性能优先模式。
线程的数量是不做限制的。每次有任务来的时候，都是以任务优先，即优先执行任务，可以理解为性能最大化。（前提是服务器的硬件能跟得上，服务器压力会比较大）
2）newFixedThreadPool()：要求性能一般，服务器的配置不是太高。
规定线程的数量，可以让服务器的压力不这么大。
3）newSingleThreadExecutor()：追求绝对的安全。
：只考虑安全，不考虑性能。如银行转账等场景。
