多线程的使用意义和使用

 

线程的出现

有了进程以后，为什么还会发明线程呢？

1. 在多核 CPU 中，利用多线程可以实现真正意义上的并行执行

2. 在一个应用进程中，会存在多个同时执行的任务，如果其中一个任务被阻塞，将会引起不依赖该任务的任务也被阻塞。通过对不同任务创建不同的线程去处理，可以提升程序处理的实时性

3. 线程可以认为是轻量级的进程，所以线程的创建、销毁比进程更快

 

如何应用多线程

在 Java 中，有多种方式来实现多线程。继承 Thread 类、实现 Runnable 接口、使用 ExecutorService、Callable、Future 实现带返回结果的多线程。

继承 Thread 类创建线程

Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread类的 start()实例方法。start()方法是一个 native 方法，它会启动一个新线程，并执行 run()方法。这种方式实现多线程很简单，通过自己的类直接 extend Thread，并重写 run()方法，就可以启动新线程并执行自己定义的 run()方法。

public class MyThread extends Thread {

public void run() {

System.out.println("MyThread.run()");

}

}

MyThread myThread1 = new MyThread();

MyThread myThread2 = new MyThread();

myThread1.start();

myThread2.start();

实现 Runnable  接口创建线程

如果自己的类已经 extends 另一个类，就无法直接 extendsThread，此时，可以实现一个 Runnable 接口

public class MyThread extends OtherClass implements

Runnable {

public void run() {

System.out.println("MyThread.run()");

}

}

 

实现  Callable  接口

通过  FutureTask  包装器来创建  Thread  线程有的时候，我们可能需要让一步执行的线程在执行完成以后，提供一个返回值给到当前的主线程，主线程需要依赖这个值进行后续的逻辑处理，那么这个时候，就需要用到带返回值的线程了。Java 中提供了这样的实现方式

public class CallableDemo implements Callable<String> {

public static void main(String[] args) throws

ExecutionException, InterruptedException {

ExecutorService executorService=

Executors. newFixedThreadPool (1);

CallableDemo callableDemo=new CallableDemo();

Future<String>

future=executorService.submit(callableDemo);

System. out .println(future.get());

executorService.shutdown();

}

@Override

public String call() throws Exception {

int a=1;

int b=2;

System. out .println(a+b);

return "执行结果:"+(a+b);

}

}

 

多线程的实际应用场

在工作中应该很少有场景能够应用多线程了，因为基于业务开发来说，很多使用异步的场景我们都通过分布式消息队列来做了。但并不是说多线程就不会被用到，如果有看一些框架的源码，会发现线程的使用无处不在。

 

线程的生命周期

Java 线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，那么我们接下来从线程的生命周期开始去了解线程。

线程一共有 6 种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）

NEW：初始状态，线程被构建，但是还没有调用 start 方法

RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”

BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况

等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列

同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中

其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O 请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复

TIME_WAITING：超时等待状态，超时以后自动返回

TERMINATED：终止状态，表示当前线程执行完毕

启动一个线程前，最好为这个线程设置线程名称，因为这样在使用 jstack 分析程序或者进行问题排查时，就会给开发人员提供一些提示显示线程的状态

 运行该示例，打开终端或者命令提示符，键入“jps”，（JDK1.5 提供的一个显示当前所有 java 进程 pid 的命令）

根据上一步骤获得的 pid，继续输入 jstack pid（jstack是 java 虚拟机自带的一种堆栈跟踪工具。jstack 用于打印出给定的 java 进程 ID 或 core file 或远程调试服务的 Java 堆栈信息）通过上面的分析，我们了解到了线程的生命周期，现在在整个生命周期中并不是固定的处于某个状态，而是随着代码的执行在不同的状态之间进行切换

线程的启动

前面演示了线程的启动，也就是调用start()方法去启动一个线程，当 run 方法中的代码执行完毕以后，线程的生命周期也将终止。调用 start 方法的语义是当前线程告诉 JVM，启动调用 start 方法的线程。

线程的启动原理

很多同学最早学习线程的时候会比较疑惑，启动一个线程为什么是调用 start 方法，而不是 run 方法，这做一个简单的分析，先简单看一下 start 方法的定义我们看到调用 start 方法实际上是调用一个 native 方法start0()来启动一个线程，首先 start0()这个方法是在

Thread 的静态块中来注册的，代码如下registerNatives 的 本 地 方 法 的 定 义 在 文 件Thread.c,Thread.c定义了各个操作系统平台要用的关于线程的公共数据和操作，以下是 Thread.c 的全部内容

http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/00cd9dc3c

 

线程的终止

线程的启动过程大家都非常熟悉，但是如何终止一个线程呢？

线程的终止，并不是简单的调用 stop 命令去。虽然 api 仍然可以调用，但是和其他的线程控制方法如 suspend、resume 一样都是过期了的不建议使用，就拿 stop 来说，stop 方法在结束一个线程时并不会保证线程的资源正常释放，因此会导致程序可能出现一些不确定的状态。要优雅的去中断一个线程，在线程中提供了一个 interrupt方法

interrupt 方法

当其他线程通过调用当前线程的 interrupt 方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己。线程通过检查资深是否被中断来进行相应，可以通过isInterrupted()来判断是否被中断。

 

那么是不是线程调用终止方法就立刻停止了呢？

答案是no，这个时候线程复位的作用就体现出来了

为什么要复位

Thread.interrupted()是属于当前线程的，是当前线程对外界中断信号的一个响应，表示自己已经得到了中断信号，但不会立刻中断自己，具体什么时候中断由自己决定，让外界知道在自身中断前，他的中断状态仍然是 false，这就是复位的原因。

线程的终止原理

我们来看一下 thread.interrupt()方法做了什么事情这个方法里面，调用了 interrupt0()，这个方法在前面分析start 方法的时候见过，是一个 native 方法，同样，我们找到 jvm.cpp 文件，找到JVM_Interrupt 的定义这个方法比较简单，直接调用了 Thread::interrupt(thr)这个方法，这个方法的定义在 Thread.cpp 文件中，代码如下Thread::interrupt 方法调用了 os::interrupt 方法，这个是调用平台的 interrupt 方法，这个方法的实现是在 os_*.cpp文件中，其中星号代表的是不同平台，因为 jvm 是跨平台的，所以对于不同的操作平台，线程的调度方式都是不一样的。我们以 os_linux.cpp 文件为例set_interrupted(true)实际上就是调用 osThread.hpp 中的set_interrupted()方法，在 osThread 中定义了一个成员属性 volatile jint _interrupted;通过上面的代码分析可以知道，thread.interrupt()方法实际就是设置一个 interrupted 状态标识为 true、并且通过ParkEvent 的 unpark 方法来唤醒线程。

1. 对于 synchronized 阻塞的线程，被唤醒以后会继续尝试获取锁，如果失败仍然可能被 park

2. 在调用 ParkEvent 的 park 方法之前，会先判断线程的中断状态，如果为 true，会清除当前线程的中断标识

3. Object.wait 、 Thread.sleep 、 Thread.join 会 抛 出InterruptedException，为什么 Object.wait、Thread.sleep 和 Thread.join 都 会 抛 出InterruptedException? 你会发现这几个方法有一个共同点，都是属于阻塞的方法而阻塞方法的释放会取决于一些外部的事件，但是阻塞方法可能因为等不到外部的触发事件而导致无法终止，所以它允许一个线程请求自己来停止它正在做的事情。当一个方法抛出 InterruptedException 时，它是在告诉调用者如果执行该方法的线程被中断，它会尝试停止正在做的事情并且通过抛出 InterruptedException 表示提前返回。所以，这个异常的意思是表示一个阻塞被其他线程中断了。然后，由于线程调用了 interrupt()中断方法，那么Object.wait、Thread.sleep 等被阻塞的线程被唤醒以后会通过 is_interrupted 方法判断中断标识的状态变化，如果发现中断标识为 true，则先清除中断标识，然后抛出InterruptedException需要注意的是，InterruptedException 异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，至于接下来怎么处理取决于线程本身，比如

1. 直接捕获异常不做任何处理

2. 将异常往外抛出

3. 停止当前线程，并打印异常信息