前言
开心一刻
小时候有一次爸爸带我去偷村头别人家的梨子，我上树摘，爸爸在下面放风，正摘着主人来了，爸爸指着我破口大骂：臭小子，赶紧给我滚下来，敢偷吃别人家梨子，看我不打死你。主人家赶紧说：没事没事，小孩子淘气嘛，多摘点回家吃。我……这坑儿子的爹...
纯正的海豹突击队
路漫漫其修远兮，吾将上下而求索！
github：https://github.com/youzhibing
码云(gitee)：https://gitee.com/youzhibing
Runnable
如果是简单的实现一个线程，我们会通过实现Runnable接口或继承Thread类来完成。JDK1.0中就已经存在Runnable和Thread，Thread实现了Runnable接口。Runnable使用方式一般如下
public class RunnableTest {
public static void main(String[] args) {
// Java 8之前：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Before Java8, 我是子线程1");
}
}).start();
//Java 8方式：
new Thread( () -> {
System.out.println("In Java8");
System.out.println("我是子线程2");
} ).start();
}
}
一般我们的线程不是以匿名内部类的方式存在的，而是以如下方式存在
public class RunnableTest {
public static void main(String[] args) throws InterruptedException {
Runnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
Thread.sleep(1000);
System.out.println("我是主线程");
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("我是子线程1");
}
}
当然线程的实现方式还有Thread类，Thread实现了Runnable接口，本质还是一样；无论是Runnable，还是Thread，实现的线程有一个很明显的缺点，就是没有返回值，执行完任务之后无法获取执行结果。
Callable
Callable接口是JDK1.5中引入的，和Runnable类似，都是用来实现多线程，不同的是，Callable能返回结果和抛出checked exception。源代码如下
@FunctionalInterface
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
可以看到，Callable是一个泛型接口，call()函数返回的类型就是传递进来的泛型类型，也是返回的结果类型。那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，而ExecutorService的创建又是用Executors来完成的。
线程池
Executors
也是JDK1.5新增内容，是创建ExecutorService、ScheduledExecutorService、ThreadFactory和Callable的工厂，并提供了一些有效的工具方法。有很多创建ExecutorService的方法
主要分为6类方法，每一类都两两重载，一个有ThreadFactory threadFactory参数，一个没有ThreadFactory threadFactory参数，也就是我们可以自定义ThreadFactory来定制Thread；若没有ThreadFactory参数，则使用默认的DefaultThreadFactory来构建Thread。6类方法如下
newCachedThreadPool(...)
创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程；返回类型是：ThreadPoolExecutor。
newFixedThreadPool(...)
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待；返回类型是：ThreadPoolExecutor。
newScheduledThreadPool(...)
创建一个定长线程池，支持定时及周期性任务执行；返回类型是：ScheduledThreadPoolExecutor。多数情况下可用来替代Timer类。
newSingleThreadExecutor(...)
创建一个单线程化的线程池，只有唯一的一个工作线程来执行任务，保证所有任务按照指定顺序执行；返回类型是：ThreadPoolExecutor的代理，我们可以认为就是ThreadPoolExecutor。
newSingleThreadScheduledExcutor(...)
创建一个单线程化的线程池，与newSingleThreadExecutor类似，但支持定时及周期性任务执行；返回类型是：ScheduledThreadPoolExecutor。
newWorkStealingPool(...)
创建持有足够线程的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争；它需要穿一个并行级别的参数，如果不传，则被设定为默认的CPU数量。JDK1.8中新增，返回类型是：ForkJoinPool。ForkJoinFool通常配合ForkJoinTask的子类RecursiveAction或RecursiveTask使用。
常用的主要是以下3类：newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool。至于newWorkStealingPool，我还没用过，不太好评论。
ExecutorService
ExecutorService是一个interface，继承了Executor，是Java中对线程池定义的一个接口，类图如下：
ExecutorService接口中常用方法如下
void execute(Runnable command); // 从Executor继承而来，用来执行Runnale，没有返回值
<T> Future<T> submit(Callable<T> task); // 执行Callable类型的task，并返回Future
<T> Future<T> submit(Runnable task, T result); // 这种方式很少使用
Future<?> submit(Runnable task); // 执行Runnable类型的task，并返回Future
当然还有invokeAll、invokeAny，感兴趣的可以去看下。关于Future，下面会讲到。
当我们使用完成ExecutorService之后应该关闭它，否则它里面的线程会一直处于运行状态，导致应用无法停止。关闭ExecutorService的方式有两种，其一是ExecutorService.shutdown()方法，在调用shutdown()方法之后，ExecutorService不会立即关闭，但是它不再接收新的任务，直到当前所有线程执行完成才会关闭，所有在shutdown()执行之前提交的任务都会被执行；其二是调用ExecutorService.shutdownNow()方法，它将跳过所有正在执行的任务和被提交还没有执行的任务，但是它并不对正在执行的任务做任何保证，有可能它们都会停止，也有可能执行完成。一般推荐的关闭方式是ExecutorService.shutdown()。
Future
对具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。相关类图如下
public interface Future<V> {
/**
* 取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false
* @param mayInterruptIfRunning 是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
* 如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false。
* 如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false。
* 如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
* @return
*/
boolean cancel(boolean mayInterruptIfRunning);
/**
* 任务是否被取消成功，如果在任务正常完成前被取消成功，则返回true。
* @return
*/
boolean isCancelled();
/**
* 任务是否已经完成，若完成则返回true。
* @return
*/
boolean isDone();
/**
* 获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回。
* @return
* @throws InterruptedException
* @throws ExecutionException
*/
V get() throws InterruptedException, ExecutionException;
/**
* 获取执行结果，如果在指定时间内没获取到结果，就直接返回null
* @param timeout
* @param unit
* @return
* @throws InterruptedException
* @throws ExecutionException
* @throws TimeoutException
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
从如上代码可以看出Future提供了三种功能：
1、判断任务是否完成；2、中断任务；3、获取任务执行结果。
线程池使用示例
Runnable使用示例
示例一，定时周期的执行某个任务
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; public class RunnableTest { public static void main(String[] args) {
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
MyRunnable myRunnable = new MyRunnable();
// 应用启动3秒开始执行myRunnable，之后每隔5秒执行一次; scheduleAtFixedRate是有返回值的，配合Runnable的话，我们不关注返回值
executorService.scheduleAtFixedRate(myRunnable, 3, 5, TimeUnit.SECONDS);
System.out.println("我是主线程...");
}
}
class MyRunnable implements Runnable { @Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我是子线程1");
}
}
示例二，单线程化的线程池执行某个任务，并显示的关闭线程池
public class RunnableTest {
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
ExecutorService executorService = Executors.newSingleThreadExecutor();
MyRunnable myRunnable = new MyRunnable();
// 为了可取消性而使用Future但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回null作为底层任务的结果
Future<?> submit = executorService.submit(myRunnable);
// 如果不shutdown，那它里面的线程会一直处于运行状态，应用不会停止
executorService.shutdown();
// 输出任务执行结果，由于Runnable没有返回值，所以get的是null
System.out.println(submit.get(4, TimeUnit.SECONDS));
System.out.println("我是主线程...");
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我是子线程1");
}
}
Callable使用示例
示例一，Callable + Future获取结果；采用缓存线程池执行任务
import java.util.concurrent.*;
import java.util.concurrent.Future; public class CallableTest { public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newCachedThreadPool();
Task task = new Task();
Future<String> result = executorService.submit(task);
executorService.shutdown(); Thread.sleep(1000);
System.out.println("我是主线程, 执行另外的业务..."); System.out.println("task执行结果：" + result.get()); System.out.println("任务全部执行完毕...");
}
}
class Task implements Callable<String> { @Override
public String call() throws Exception {
System.out.println("子线程, 业务处理中...");
Thread.sleep(2000);
return "业务执行成功";
}
}
示例二，Callable + FutureTask获取结果；采用定长线程池执行定时任务
import java.util.concurrent.*;
public class CallableTest {
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
ExecutorService executorService = Executors.newCachedThreadPool();
Task task = new Task();
FutureTask<String> futureTask = new FutureTask<>(task);
executorService.submit(futureTask);
executorService.shutdown();
Thread.sleep(1000);
System.out.println("我是主线程, 执行另外的业务...");
System.out.println("task执行结果：" + futureTask.get(5, TimeUnit.SECONDS));
System.out.println("任务全部执行完毕...");
}
}
class Task implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("子线程, 业务处理中...");
Thread.sleep(2000);
return "业务执行成功";
}
}
shiro中session验证定时任务
shiro源码篇 - shiro的session的查询、刷新、过期与删除，你值得拥有中讲到了session验证定时任务，我们AbstractValidatingSessionManager中createSession方法开始
可以看到，调用Executors.newSingleThreadScheduledExcutor(ThreadFactory threadFactory)方法创建了一个支持定时及周期性执行的单线程化线程池，支持定时及周期性地执行task，并且线程池中只有一个线程。ExecutorServiceSessionValidationScheduler本身就是一个Runnable，那么会定时、周期性的执行其run()。说的简单点就是：应用启动60分钟后，单线程化的线程池中的单个线程开始执行ExecutorServiceSessionValidationScheduler的run()方法，之后每隔60分钟执行一次，60分钟是默认设置；ExecutorServiceSessionValidationScheduler的run()中，会调用sessionManager的validateSessions()方法完成session的验证。
总结
1、无需返回结果，简单的线程实现可以用Runnable（或Thread）；需要返回结果的、稍复杂的线程实现可以用Callable；如果线程操作频繁、需要连接池管理的可以考虑用ExecutorService来实现线程池；更复杂的任务调度，则可以用三方工具，比如：quartz，更多三方调度工具可查阅spring-boot-2.0.3之quartz集成，不是你想的那样哦！，具体选择哪个，需要结合我们的具体业务来考虑，没有绝对的选择谁而不选择谁，就看谁更契合；
2、一般情况下，Callable(或Runnale)、Executors、ExecutorService、Future会配合来使用，很多时候我们不需要返回值，则可以不关注Future；推荐使用线程池的方式，有与数据库连接池类似的优点；
3、很多三方的框架、工具都沿用了jdk的线程池实现，而没有引用第三方调度工具，例如shiro中，session的验证定时任务就是沿用的jdk中的Executors.newSingleThreadScheduledExcutor(ThreadFactory threadFactory)来创建的线程池；
4、jdk中的线程还有很多内容，本文只是涉及到了冰山一角，更深入的学习有待大家自行去进行。