今天，我们开始Java高并发与多线程的第二篇，线程的实现方式。
通常来讲，线程有三种基础实现方式，一种是继承Thread类，一种是实现Runnable接口，还有一种是实现Callable接口，当然，如果我们铺开，扩展一下，会有很多种实现方式，但是归根溯源，其实都是这几种实现方式的衍生和变种。
我们依次来讲。
【第一种 · 继承Thread】
继承Thread之后，要实现父类的run方法，然后在起线程的时候，调用其start方法。
1 public class DemoThreadDemoThread extends Thread {
2 public void run() {
3 System.out.println("我执行了一次！");
4 }
5
6 public static void main(String[] args) throws InterruptedException {
7 for (int i = 0; i < 3; i++) {
8 Thread thread = new DemoThreadDemoThread();
9 thread.start();
10 Thread.sleep(3000);
11 }
12 }
13 }
这里，有些同学对start方法和run方法的作用理解有点问题，解释一下：
|
start()方法被用来启动新创建的线程，在start()内部调用了run()方法。 当你调用run()方法的时候，其实就和调用一个普通的方法没有区别。 |
【第二种 · 实现Runnable接口】
第二种方法，是实现Runnable接口的run方法，在起线程的时候，如下，new一个Thread类，然后把类当做参数传进去。
1 public class DemoThreadDemoRunnable implements Runnable {
2 public void run() {
3 System.out.println("我执行了一次！");
4 }
5
6 public static void main(String[] args) throws InterruptedException {
7 for (int i = 0; i < 3; i++) {
8 Thread thread = new Thread(new DemoThreadDemoRunnable());
9 thread.start();
10 Thread.sleep(3000);
11 }
12 }
13 }
- 两种基础实现方式的选择
这两种方法看起来其实差不多，但是平时使用的时候我们如何做选择呢？
一般而言，我们选择Runnable会好一点；
首先，我们从代码的架构考虑。
实际上，Runnable 里只有一个 run() 方法，它定义了需要执行的内容，在这种情况下，实现了 Runnable 与 Thread 类的解耦，Thread 类负责线程启动和属性设置等内容，权责分明。
第二点就是在某些情况下可以提高性能。
使用继承 Thread 类方式，每次执行一次任务，都需要新建一个独立的线程，执行完任务后线程走到生命周期的尽头被销毁，如果还想执行这个任务，就必须再新建一个继承了 Thread 类的类，如果此时执行的内容比较少，比如只是在 run() 方法里简单打印一行文字，那么它所带来的开销并不大，相比于整个线程从开始创建到执行完毕被销毁，这一系列的操作比 run() 方法打印文字本身带来的开销要大得多。
如果我们使用实现 Runnable 接口的方式，就可以把任务直接传入线程池，使用一些固定的线程来完成任务，不需要每次新建销毁线程，大大降低了性能开销。
第三点好处在于可以继承其他父类。
Java 语言不支持双继承，如果我们的类一旦继承了 Thread 类，那么它后续就没有办法再继承其他的类，这样一来，如果未来这个类需要继承其他类实现一些功能上的拓展，它就没有办法做到了，相当于限制了代码未来的可拓展性。
- 为什么说Runnable和Thread其实是同一种创建线程的方法？
首先，我们可以去看看Thread的源码，我们可以看到：
其实Thread类也是实现了Runnable接口，以下是Thread的run方法：
其中的target指的就是你是实现了Runnable接口的类：
Thread被new出来之后，调用Thread的start方法，会调用其run方法，然后其实执行的就是Runnable接口的run方法（实现后的方法）。
所以，当你继承了Thread之后，你实现的run方法其实还是Runnable接口的run方法，
因此，其实无返回值线程的实现方式只有一种，那就是实现Runnable接口的run方法，然后调用Thread的start方法，start方法内部会调用你写的run方法，完成代码逻辑。
【第三种 · 实现Callable接口】
第 3 种线程创建方式是通过有返回值的 Callable 创建线程。
Callable接口实际上是属于Executor框架中的功能类，之后的部分会详细讲述Executor框架。
Callable和Runnable可以认为是兄弟关系，Callable的call()方法类似于Runnable接口中run()方法，都定义任务要完成的工作，实现这两个接口时要分别重写这两个方法；
主要的不同之处是call()方法是有返回值的，运行Callable任务可以拿到一个Future对象，表示异步计算的结果。
我们通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
代码示例如下：
1 public class DemoThreadDemoCallable implements Callable<Integer> {
2
3 private volatile static int count = 0;
4
5 public Integer call() {
6 System.out.println("我是callable，我执行了一次");
7 return count++;
8 }
9
10 public static void main(String[] args) throws InterruptedException, ExecutionException {
11 List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();
12
13 for (int i = 0; i < 3; i++) {
14 FutureTask<Integer> futureTask = new FutureTask<Integer>(new DemoThreadDemoCallable());
15 taskList.add(futureTask);
16 }
17
18 for (FutureTask<Integer> task : taskList) {
19 Thread.sleep(1000);
20 new Thread(task).start();
21 }
22
23 // 一般这个时候是做一些别的事情
24 Thread.sleep(3000);
25 for (FutureTask<Integer> task : taskList) {
26 if (task.isDone()) {
27 System.out.printf("我是第%s次执行的！\n", task.get());
28 }
29 }
30 }
31 }
执行结果如下：
|
其中，count 使用volatile 修饰了一下，关于volatile 关键字，之后会再次讲到，这里先不说。 |
当然了，我们一般情况下，都会使用线程池来进行Callable的调用，如下代码所示。
1 public class DemoThreadDemoCallablePool {
2 public static void main(String[] args) {
3 ExecutorService threadPool = Executors.newSingleThreadExecutor();
4 Future<Integer> future = threadPool.submit(new DemoThreadDemoCallable());
5 try {
6 System.out.println(future.get());
7 } catch (Exception e) {
8 System.err.print(e.getMessage());
9 } finally {
10 threadPool.shutdown();
11 }
12 }
13 }
- Callable和Runnable的区别
最后，我们来看看Callable和Runnable的区别：
- Callable规定的方法是call()，而Runnable规定的方法是run()
- Callable的任务执行后可返回值，而Runnable的任务是不能返回值的（运行Callable任务可拿到一个Future对象， Future表示异步计算的结果）
- call()方法可抛出异常，而run()方法是不能抛出异常的
【三种创建线程的基础方式图示】
通过图示基本上可以看得很清楚，Callable是需要Future接口的实现类搭配使用的；
Future接口一共有5个方法：
-
- boolean cancel(boolean mayInterruptIfRunning)
用于取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。
参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
如果任务已经完成，此方法返回false，即取消已经完成的任务会返回false；
如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；
如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
-
- boolean isCancelled()
如果在Callable任务正常完成前被取消，返回True
-
- boolean isDone()
若Callable任务完成，返回True
-
- V get() throws InterruptedException, ExecutionException
返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
-
- V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null
事实上，FutureTask是Future接口唯一一个实现类。（只看了1.7和1.8，后面的版本没有check）
【JVM线程模型】
在上一节的时候我们讲了线程的生命周期和状态，其实每一个线程，从创建到销毁，都占用了大量的CPU和内存，但是真正执行任务锁占用的资源可能并没有很多，可能只能占用到里面很少的一部分。
在java里面，使用线程执行异步任务的时候，如果每次都创建一个新的线程，那么系统资源会大量被占用，服务器会一直处于超高负荷的运算，最终很容易就会造成系统崩溃。
从jdk1.5开始，java将工作单元和执行机制分离，工作单元主要包括Runnable和Callable，执行机制就是Executor框架。
在HotSpot VM的线程模型中，Java线程会被一对一的映射成本地操作系统线程。（Java线程创建的时候，操作系统里面会对应创建一个线程，Java线程被销毁，操作系统中的线程也被销毁）
在应用层，Java多线程程序会将整个应用分解成多个任务，然后运行的时候，会使用Executor将这些任务分配给固定的一些线程去分别执行，而底层操作系统内核会将这些线程映射到硬件处理器上，调用CPU进行执行。
类似下图：
【Executor框架】
以上，是Executor框架结构图解。
Executor框架包括3大部分：
-
- 任务
也就是工作单元，包括被执行任务需要实现的接口（Runnable/Callable）
-
- 任务的执行
把任务分派给多个线程的执行机制，包括Executor接口及继承自Executor接口的ExecutorService接口。
-
- 异步计算的结果
包括Future接口及实现了Future接口的FutureTask类。
-
- Executor
Executor框架的基础，将任务的提交和执行分离开。
-
- TreadPoolExecutor
线程池的核心实现类，用来执行被提交的任务。
通常使用Executors创建，一共有三种类型的ThreadPoolExecutor：
-
-
- SingleThreadExecutor（单线程）
- FixedThreadPool（限制当前线程数量）
- CachedThreadPool（大小*的线程池）
-
-
- ScheduledThreadPoolExecutor
实现类，可以在一个给定的延迟时间后，运行命令，或者定期执行。
通常也是由Executor创建，一共有两种类型的ScheduledThreadPoolExecutor。
-
-
- ScheduledThreadPoolExecutor（包含多个线程，周期性执行）
- SingleThreadScheduledExecutor（只包含一个线程）
-
-
- Future
异步计算的结果。
这里在很多时候返回的是一个FutureTask的对象，但是并不是必须是FutureTask，只要是Future的实现类即可。
【TreadPoolExecutor】
之前已经说过，TreadPoolExecutor是线程池的核心实现类，所有线程池的底层实现都依靠它的构造函数：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
我们可以依次解释一下：
- corePoolSize
核心线程数，也叫常驻线程数，线程池里从创建之后会一直存在的线程数量。
- maximumPoolSize
最大线程数，线程池中最多存在的线程数量。
- keepAliveTime
空闲线程的存活时间，一个线程执行完任务之后，等待多久会被线程池回收。
- unit
keepAliveTime参数的单位
- workQueue
线程队列（一般为阻塞队列）
- threadFactory
线程工厂，用于创建线程
- handler
拒绝策略，由于达到线程边界和队列容量而阻止执行时使用的处理程序。
其实，线程池不能算作一种创建线程的方式，为什么呢？
|
对于线程池而言，本质上是通过线程工厂创建线程的。 默认采用 DefaultThreadFactory ，它会给线程池创建的线程设置一些默认值，比如：线程的名字、是否是守护线程，以及线程的优先级等。
|
关于线程池的详细概念内容，可先参考我的另外一篇博客：线程池略略观，后面也会再说。
关于线程的主要创建方式，大概就是以上这些，下一篇，会讲线程的基本属性和主要方法。