本文将涵盖两个主题：
* 通过实现Callable接口创建线程
* 在Java中使用Executor框架
实现Callable接口
为了创建一段可以在线程中运行的代码，我们创建了一个类，然后实现了Callable接口。这段代码完成的任务需要放在call（）函数中。在下面的代码中，你可以看到Callable task是一个实现Callable接口的类，在函数中完成了将0到4之间的数字相加的任务。
package com.mzc.common.thread;
import java.util.concurrent.Callable;
/**
* <p class="detail">
* 功能: 实现Callable接口
* </p>
*
* @author Moore
* @ClassName Callable task.
* @Version V1.0.
* @date 2019.12.23 10:06:23
*/
public class CallableTask implements Callable<Integer> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += i;
}
return sum;
}
}在上面的代码中，你会注意到Callable的参数为Integer。这表明此Callable的返回类型将为Integer。还可以看到调用函数返回了Integer类型。
1、创建线程并运行
下面的代码显示了如何创建线程，然后运行它们。
package com.mzc.common.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableInterfaceDemo {
public static void main(String[] args) {
FutureTask<Integer>[] futureList = new FutureTask[5];
for (int i = 0; i <= 4; i++) {
Callable<Integer> callable = new CallableTask();
futureList[i] = new FutureTask<Integer>(callable);
Thread t = new Thread(futureList[i]);
t.start();
}
for (int i = 0; i <= 4; i++) {
FutureTask<Integer> result = futureList[i];
try {
System.out.println("Future Task" + i + ":" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}为了创建线程，首先我们需要创建一个CallableTask实例，该实例实现CallableI接口，如图所示：
Callable<Integer> callable = new CallableTask();然后我们需要创建一个FutureTask类的实例，并将Callable Task的实例作为参数传递，如下所示：
futureList[i] = new FutureTask<Integer>(callable);然后创建一个线程，我们创建一个Thread类的实例，并将FutureTask类的实例作为参数传递，如下所示：
Thread t = new Thread(futureList[i]);最后，使用start()方法启动线程。
2、从线程获取结果
如果是Callables，线程实际上可以返回一个值。为了获得该值，我们可以在FutureTask实例上调用get（）函数。在我们的代码中，线程的返回值是0到4之间的数字之和。如下面的代码片段所示：
FutureTask<Integer> result = futureList[i];
try {
System.out.println("Future Task" + i + ":" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}线程可能抛出异常，可以使用try catch块进行处理。
运行结果：
Future Task0:10
Future Task1:10
Future Task2:10
Future Task3:10
Future Task4:10**小课堂**
上面示例中，我们使用了new Thread()方式创建一个线程，但在实际项目中我们很少这样用，因为每次new的时候都是新建了一个线程对象，并且不能复用，只能释放线程资源，这种方式性能较差，而且如果不加限制，创建太多的线程会消耗太多系统资源，同时线程太多，如果要定期执行、关闭线程等，都不方便统一管理。
所以我们就需要线程池来管理线程，使用线程池有以下优点：
* 可以复用线程，减少对象创建，就减少系统资源消耗
* 可以控制最大并发线程数，提高系统资源利用率
* 使用线程池可以避免资源竞争，也就减少了阻塞情况
* 创建线程池简单方便，同时便于统一管理
Executor框架
每次创建线程都是资源密集型的。一个很好的替代方法是提前设置好一些线程，也就是我上面说的线程池，然后将我们的任务分配给这些线程。这就是Executors类和ExecutorService非常有用的地方。
上图显示了具有4个线程的线程池。每当我们希望运行任何任务时，都可以将其分配给这些线程。任务完成后，线程将被释放以执行其他任务。
1、如何使用Executor框架
我们还是先复用上面实现了Callable接口的CallableTask实例，然后我们改造一下创建线程方式，不再使用new Thread() 创建一个线程，而是先创建一个ExecutorService，Executors类具有ExecutorService的多个实现，这儿我们使用Executors类创建大小为4的固定线程池(newFixedThreadPool)。
ExecutorService executors = Executors.newFixedThreadPool(4);接下来，我们需要将我们的任务提交给ExecutorService，像这样：
Future<Integer> future = executors.submit(w);提交任务后，我们将获得一个Future对象的实例。Future对象将存储Task的结果。完整代码：
package com.mzc.common.thread;
import java.util.concurrent.*;
/**
* <p class="detail">
* 功能: 使用Executor创建多线程
* </p>
*
* @author Moore
* @ClassName Executor demo.
* @Version V1.0.
* @date 2019.12.23 10:54:31
*/
public class ExecutorDemo {
public static void main(String[] args) {
/**
* 创建线程池的6种方式
*/
// 1、创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
ExecutorService executors = Executors.newFixedThreadPool(4);
// 2、创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
// ExecutorService executors = Executors.newCachedThreadPool();
// 3、创建一个定长线程池，支持定时及周期性任务执行。
// ExecutorService executors = Executors.newScheduledThreadPool(4);
// 4、创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
// ExecutorService executors = Executors.newSingleThreadExecutor();
// 5、newWorkStealingPool工作窃取线程池，它是新的线程池类ForkJoinPool的扩展，
// 但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），
// 所以适合使用在很耗时的任务中
// ExecutorService executors = Executors.newWorkStealingPool(4);
// 6、newSingleThreadScheduledExecutor创建线程池同时放入多个线程时，每个线程都会按照自己的调度来执行，
// 但是当其中一个线程被阻塞时，其它的线程都会受到影响被阻塞，
// 不过依然都会按照自身调度来执行，但是会存在阻塞延迟。
// ExecutorService executors = Executors.newSingleThreadScheduledExecutor();
Future<Integer>[] futures = new Future[5];
Callable<Integer> w = new CallableTask();
try {
for (int i = 0; i < 5; i++) {
Future<Integer> future = executors.submit(w);
futures[i] = future;
}
for (int i = 0; i < futures.length; i++) {
try {
System.out.println("Result from Future " + i + ":" + futures[i].get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
} finally {
executors.shutdown();
}
}
}2、获取结果
为了获得每个任务的结果，我们可以调用Future实例的get（）方法，方法和上面的一样：
for (int i = 0; i < futures.length; i++) {
try {
System.out.println("Result from Future " + i + ":" + futures[i].get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}运行结果
Result from Future 0:10
Result from Future 1:10
Result from Future 2:10
Result from Future 3:10
Result from Future 4:10固定线程池(newFixedThreadPool)的运行情况说明：
* 在上面的示例中，我们创建了一个大小为4的固定线程池。
* 如果我们总共向ExecutorService提交3个任务，那么所有3个任务都将分配给线程池，并且它们将开始执行。
* 如果我们向ExecutorService提交4个任务，那么所有这4个任务将再次分配给线程池，并且它们将开始执行。
* 如果我们向该线程池提交5个任务，只有4个任务将分配给线程池。这是因为线程池的大小为4。仅当释放池中的线程之一时，才会分配第五个任务。
关闭ExecutorService
当我们不再需要线程时，需要关闭ExecutorService，这样做能确保JVM不会消耗其他资源。我们可以使用下面这个命令关闭ExecutorService：
executors.shutdown();ExecutorService的关闭操作通常位于``finally''块中。这是为了确保即使在发生任何异常的情况下，关闭操作始终在代码的末尾被执行。如果关闭操作不正确，那么如果发生任何异常，则ExecutorService仍将运行并消耗其他JVM资源。
总结
线程池的一些常用方法
* submit()：提交任务，能够返回执行结果execute+Future
* shutdown()：关闭线程池，等待任务都执行完
* getPoolSize()：线程池当前线程数量
* getActiveCount()：当前线程池中正在执行任务的线程数量
* shutdownNow()：关闭线程池，不等待任务执行完
* getTaskCount()：线程池已执行和未执行的任务总数
* getCompletedTaskCount()：已完成的任务数量
创建线程池的6种方式
1. newFixedThreadPool()：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
2. EnewCachedThreadPool()：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
3. newScheduledThreadPool()：创建一个定长线程池，支持定时及周期性任务执行。
4. newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(*FIFO*,* LIFO*,优先级)执行。
5. newWorkStealingPool()：工作窃取线程池，它是新的线程池类*ForkJoinPool*的扩展，但是都是在统一的一个*Executors*类中实现，由于能够合理的使用*CPU*进行对任务操作（并行操作），所以适合使用在很耗时的任务中。
6. newSingleThreadScheduledExecutor()：*newSingleThreadScheduledExecutor*创建线程池同时放入多个线程时，每个线程都会按照自己的调度来执行，但是当其中一个线程被阻塞时，其它的线程都会受到影响被阻塞，不过依然都会按照自身调度来执行，但是会存在阻塞延迟。
代码示例
// 1、创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
ExecutorService executors = Executors.newFixedThreadPool(4);
// 2、创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
ExecutorService executors = Executors.newCachedThreadPool();
// 3、创建一个定长线程池，支持定时及周期性任务执行。
ExecutorService executors = Executors.newScheduledThreadPool(4);
// 4、创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
ExecutorService executors = Executors.newSingleThreadExecutor();
// 5、newWorkStealingPool工作窃取线程池，它是新的线程池类ForkJoinPool的扩展，
// 但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），
// 所以适合使用在很耗时的任务中
ExecutorService executors = Executors.newWorkStealingPool(4);
// 6、newSingleThreadScheduledExecutor创建线程池同时放入多个线程时，每个线程都会按照自己的调度来执行，
// 但是当其中一个线程被阻塞时，其它的线程都会受到影响被阻塞，
// 不过依然都会按照自身调度来执行，但是会存在阻塞延迟。
ExecutorService executors = Executors.newSingleThreadScheduledExecutor();如果觉得本文觉得还行，可以关注我的个人公众号：码之初。给与我更多写下去的动力，谢谢！码之初将为您奉献：
* Java基础到架构知识全方位涵盖
* 海量面试资料，从文档到视频，从基础到底层，面试无忧
* 程序猿生活记录，程序猿的生活也值得关注
* 不定期的福利发放，惊喜就是在不经意间来临。
