1. 线程概念

1. 并发的发展历程

• 早期的计算机穿孔打卡
  同一时刻只能运行一个程序，程序输入过程中，计算机处于空闲状态
• 晶体管和批处理系统：
  a: 程序员把卡片拿到 1401 机 b: 1401 机把批处理作业读到磁带上
  c: 操作员把输入磁带送到熬 7094 机 d: 7094 机进行计算
  e: 操作员把输出磁带送到 1401 机 f:1401 机打印输出
  
  缺点：某一个作业因为等待磁盘或其他IO操作而暂停时，CPU只能阻塞直到该IO完成，IO操作多的场景，CPU资源浪费严重
• 集成电路和多道程序设计——进程的出现
  把内存分为多个部分，每个部分放不同的程序。当一个程序需要等待I/O 操作完成时, CPU 可以切换执行内存中的另外一个程序。如果内存中可以同时存放足够多的程序，那 CPU的利用率可以接近 100%
  在这个时候，引入了第一个概念- 进程, 进程的本质是一个正在执行的程序，程序运行时系统会创建一个进程，并且给每个进程分配独立的内存地址空间保证每个进程地址不会相互干扰。同时，在 CPU 对进程做时间片的切换时，保证进程切换过程中仍然要从进程切换之前运行的位置出开始执行。所以进程通常还会包括程序计数器、堆栈指针。
• 线程
  线程是操作系统执行程序的最小操作单元，一个进程可以创建多个线程。

1. 单线程中，多线程本质是通过切换CPU时间片切换给不同的线程去执行，在多核 CPU 中，利用多线程可以实现真正意义上的并行执行
2. 在一个应用进程中，会存在多个同时执行的任务，如果其中一个任务被阻塞，将会引起不依赖该任务的任务也被阻塞。通过对不同任务创建不同的线程去处理，可以提升程序处理的实时性
3. 线程可以认为是轻量级的进程，所以线程的创建、销毁比进程更快

2.并发和并行

• 并发/高并发
  以tomcat为例，它默认的并发数是150，当超过这个值的时候，就会出现一些请求响应变慢，无法获取连接等问题，那么它能够承受的并发数量（单位时间内能够处理的请求的数量）由什么因素决定？ 一台服务器能承载的最大并发数量，是由硬件资源和软件层面共同决定的。
  在系统硬件资源（CPU 内存 磁盘 网络）不可改变的情况下，想要提高并发量，在软件层面可以通过以下方面最大化的利用硬件资源来提升

线程数量; >JVM 内存分配大小 ;网络通信机制（NIO BIO AIO）,磁盘IO

• 线程数量如何提升服务端的并发数量
  CPU决定了软件层面能够创建的线程的最大数量。一个CPU同一时刻只能去处理一件事情。
• 并发和并行的区别
  并发是服务器端能够同时处理的请求的数量，并行是当前CPU能够同时处理的线程的数量；
  单核CPU也可以支持多线程，但是它是通过CPU时间片切换去执行不同的线程的。
  Erlang 之父 Joe Armstrong 用一张5岁小孩都能看懂的图解释了并发与并行的区别：
  
  并发是两个队列交替使用一台咖啡机
  并行是两个队列同时使用两台咖啡机，如果串行，一个队列使用一台咖啡机，那么哪怕前面那个人便秘了去厕所呆半天，后面的人也只能死等着他回来才能去接咖啡，这效率无疑是最低的。
  Question: 并发是不是一个线程，并行是多个线程？
  —— 并发和并行都可以是很多个线程，就看这些线程能不能同时被（多个）cpu执行，如果可以就说明是并行，而并发是多个线程被（一个）cpu 轮流切换着执行。

3. 多线程的特点

• 异步
  异步是相对同步来说。什么是同步？ 假设你发微信给别人，然后等待回复，别人未回复之前，你一直等，直到回复了你再继续发
  异步就是微信发完了就不管了，接着做其他事情，比如看个视频等。异步可以理解为不阻塞当前的处理过程，如下图，上面部分是同步执行，下面部分是异步执行，异步执行对于请求的处理时间影响很大：
  
• 并行
  并行就是同时执行
  

2. Java中的线程

Java中创建线程的方式有：

• 继承Thread类

package com.example.springbootthreaddemo;public class TestDemo extends Thread{@Overridepublic void run() {//线程会执行的指令try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " Come in");}public static void main(String[] args) {TestDemo testDemo=new TestDemo();testDemo.setName("SubThread");testDemo.start();// 线程异步：这里子线程睡眠2s，主线程会先执行完。如果线程是同步的，那么主线程应该等到子线程执行完才会输出System.out.println("Main end");}
}

结果说明了线程是异步执行的，上面代码中子线程睡眠2s，主线程先执行完。如果线程是同步的，那么主线程应该等到子线程执行完才会输出结果。

• 实现Runnable接口
• 实现Callable接口
  实现Callable接口与实现Runnable接口创建线程的区别是，前者能够得到线程执行的返回值。示例：

package com.example.springbootthreaddemo;
import java.util.concurrent.*;public class CallableDemo implements Callable<String> {@Overridepublic String call() throws Exception {System.out.println("come in");Thread.sleep(1000);System.out.println("Sub thread sleep 1s");Thread.sleep(1000);System.out.println("Sub thread sleep 2s");return "SUCCESS";}public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executorService=Executors.newFixedThreadPool(1);CallableDemo callableDemo=new CallableDemo();Future<String> future=executorService.submit(callableDemo);//阻塞 这里future.get是阻塞的，当call方法没有执行完，future.get()是得不到执行结果的System.out.println("Main thread get result = "+future.get());}
}

从上面执行结果可以看到，主线程在子线程睡眠结束，返回之后，才能拿到子线程的执行结果，也就是说future.get()是同步阻塞执行的。

多线程实际使用案例：

package com.example.springbootthreaddemo;
import com.example.springbootthreaddemo.persistence.User;
import com.example.springbootthreaddemo.service.IUserService;
import com.example.springbootthreaddemo.service.SmsClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;@RestController
public class UserController {@AutowiredSmsClient smsClient;@AutowiredIUserService userService;ExecutorService executorService= Executors.newFixedThreadPool(10);@PostMapping("/sms/user")public String register(User user){long start=System.currentTimeMillis();userService.insert(user);//异步.  Future ->//会创建N个线程//MQ来代替executorService.submit(new Runnable() {@Overridepublic void run() {smsClient.sendSms("16607691862");}});long end=System.currentTimeMillis();return "SUCCESS:"+(end-start);}
}

在上面代码中，SmsClient是一个真实的短信发送工具类，代码逻辑是，用户注册之后，数据库保存用户信息，然后通过短信网关平台向用户发送一条注册成功的短信。如果不使用多线程来发送短信（代码如下），那么这个接口所消耗的时间就是入库用户信息的时间 加上 调用短信平台发送短信成功返回后所消耗的时间，而使用线程池去发送短信之后，整个接口的消耗时间只有入库用户信息的时间，这就是线程异步执行的意义。

@PostMapping("/sms/user")public String register(User user){long start=System.currentTimeMillis();userService.insert(user);smsClient.sendSms("16607691862");long end=System.currentTimeMillis();return "SUCCESS:"+(end-start);}

总结： 我们可以通过多线程的并行执行和异步化的执行来提升软件处理的性能，从而减小请求在某个处理上的耗时，单个请求处理耗时降低之后，那么CPU就有更多的资源去处理更多的请求，这也是线程异步执行的意义。

3. 多线程基础

3.1 线程的生命周期

线程的启动到结束，有一个过程，每个过程都对应不同的状态。如下示例：

package com.example.springbootthreaddemo.demo02;
import com.mysql.cj.util.TimeUtil;
import java.util.concurrent.TimeUnit;public class Demo {public static void main(String[] args) {new Thread(()->{while(true){try {TimeUnit.SECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}//阻塞状态 ： 子线程通过睡眠阻塞的主线程的执行},"STATUS_01").start();  new Thread(()->{while(true){synchronized (Demo.class){try {Demo.class.wait(); } catch (InterruptedException e) {e.printStackTrace();}}}//阻塞状态  调用wait()进行阻塞},"STATUS_02").start(); new Thread(new BlockedDemo(),"BLOCKED-DEMO-01").start();new Thread(new BlockedDemo(),"BLOCKED-DEMO-02").start();}static class BlockedDemo extends  Thread{@Overridepublic void run() {// 加上类锁synchronized (BlockedDemo.class){while(true){try {TimeUnit.SECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}}
}

上面代码中创建了四个线程。STATUS_01 线程通过睡眠阻塞主线程，STATUS_02 通过调用wait()方法进行阻塞，
后面两个线程BLOCKED-DEMO-01 和BLOCKED-DEMO-02 会进行锁的抢占，抢到锁的线程，睡眠100ms后再进行锁的释放； 如何查看线程状态呢？ 在启动代码运行后打开IDEA的terminal终端，输入命令 jps 查看当前进程的PID ,然后使用 jstack PID 去查看这个进程对应的线程的堆栈信息：

2020-05-17 23:23:57
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.181-b13 mixed mode):"DestroyJavaVM" #18 prio=5 os_prio=0 tid=0x0000000000ffc000 nid=0x2eec waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"BLOCKED-DEMO-02" #17 prio=5 os_prio=0 tid=0x000000001ba23800 nid=0x29e4 waiting for monitor entry [0x000000001c48f000]java.lang.Thread.State: BLOCKED (on object monitor)at com.example.springbootthreaddemo.demo02.Demo$BlockedDemo.run(Demo.java:46)- waiting to lock <0x00000000d6721898> (a java.lang.Class for com.example.springbootthreaddemo.demo02.Demo$BlockedDemo)at java.lang.Thread.run(Thread.java:748)"BLOCKED-DEMO-01" #15 prio=5 os_prio=0 tid=0x000000001ba22800 nid=0x3d2c waiting on condition [0x000000001c38e000]java.lang.Thread.State: TIMED_WAITING (sleeping)at java.lang.Thread.sleep(Native Method)at java.lang.Thread.sleep(Thread.java:340)at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)at com.example.springbootthreaddemo.demo02.Demo$BlockedDemo.run(Demo.java:46)- locked <0x00000000d6721898> (a java.lang.Class for com.example.springbootthreaddemo.demo02.Demo$BlockedDemo)at java.lang.Thread.run(Thread.java:748)"STATUS_02" #13 prio=5 os_prio=0 tid=0x000000001ba41000 nid=0x272c in Object.wait() [0x000000001c28f000]java.lang.Thread.State: WAITING (on object monitor)at java.lang.Object.wait(Native Method)- waiting on <0x00000000d63f8ef0> (a java.lang.Class for com.example.springbootthreaddemo.demo02.Demo)at java.lang.Object.wait(Object.java:502)at com.example.springbootthreaddemo.demo02.Demo.lambda$main$1(Demo.java:28)- locked <0x00000000d63f8ef0> (a java.lang.Class for com.example.springbootthreaddemo.demo02.Demo)at com.example.springbootthreaddemo.demo02.Demo$$Lambda$2/443308702.run(Unknown Source)at java.lang.Thread.run(Thread.java:748)"STATUS_01" #12 prio=5 os_prio=0 tid=0x000000001ba3f000 nid=0x4654 waiting on condition [0x000000001c18f000]java.lang.Thread.State: TIMED_WAITING (sleeping)at java.lang.Thread.sleep(Native Method)at java.lang.Thread.sleep(Thread.java:340)at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)at com.example.springbootthreaddemo.demo02.Demo.lambda$main$0(Demo.java:17)at com.example.springbootthreaddemo.demo02.Demo$$Lambda$1/205797316.run(Unknown Source)at java.lang.Thread.run(Thread.java:748)"Service Thread" #11 daemon prio=9 os_prio=0 tid=0x0000000019ed4000 nid=0x540 runnable [0x0000000000000000]java.lang.Thread.State: RUNNABLE"C1 CompilerThread3" #10 daemon prio=9 os_prio=2 tid=0x0000000019ebd000 nid=0x3bd8 waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"C2 CompilerThread2" #9 daemon prio=9 os_prio=2 tid=0x0000000019eb9000 nid=0x25c4 waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"C2 CompilerThread1" #8 daemon prio=9 os_prio=2 tid=0x0000000019e85800 nid=0x2e2c waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"C2 CompilerThread0" #7 daemon prio=9 os_prio=2 tid=0x0000000019e82800 nid=0x2bec waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"Monitor Ctrl-Break" #6 daemon prio=5 os_prio=0 tid=0x0000000019e7e800 nid=0xe64 runnable [0x000000001b28e000]java.lang.Thread.State: RUNNABLEat java.net.SocketInputStream.socketRead0(Native Method)at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)at java.net.SocketInputStream.read(SocketInputStream.java:171)at java.net.SocketInputStream.read(SocketInputStream.java:141)at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)- locked <0x00000000d6453568> (a java.io.InputStreamReader)at java.io.InputStreamReader.read(InputStreamReader.java:184)at java.io.BufferedReader.fill(BufferedReader.java:161)at java.io.BufferedReader.readLine(BufferedReader.java:324)- locked <0x00000000d6453568> (a java.io.InputStreamReader)at java.io.BufferedReader.readLine(BufferedReader.java:389)at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000000019bf8000 nid=0x3e40 waiting on condition [0x0000000000000000]java.lang.Thread.State: RUNNABLE"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x0000000019c4a800 nid=0x3704 runnable [0x0000000000000000]java.lang.Thread.State: RUNNABLE"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x00000000184f2000 nid=0x5ec in Object.wait() [0x000000001af2f000]java.lang.Thread.State: WAITING (on object monitor)at java.lang.Object.wait(Native Method)- waiting on <0x00000000d6188ed0> (a java.lang.ref.ReferenceQueue$Lock)at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)- locked <0x00000000d6188ed0> (a java.lang.ref.ReferenceQueue$Lock)at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216)"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x00000000033de000 nid=0x8fc in Object.wait() [0x000000001ae2e000]java.lang.Thread.State: WAITING (on object monitor)at java.lang.Object.wait(Native Method)- waiting on <0x00000000d6186bf8> (a java.lang.ref.Reference$Lock)at java.lang.Object.wait(Object.java:502)at java.lang.ref.Reference.tryHandlePending(Reference.java:191)- locked <0x00000000d6186bf8> (a java.lang.ref.Reference$Lock)at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)"VM Thread" os_prio=2 tid=0x00000000184e6800 nid=0x3f98 runnable"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x00000000032fb000 nid=0x3994 runnable"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x00000000032fc800 nid=0x24fc runnable"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x00000000032fe800 nid=0x4740 runnable"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x0000000003300000 nid=0x22fc runnable"GC task thread#4 (ParallelGC)" os_prio=0 tid=0x0000000003303000 nid=0x3f90 runnable"GC task thread#5 (ParallelGC)" os_prio=0 tid=0x0000000003304800 nid=0x3878 runnable"GC task thread#6 (ParallelGC)" os_prio=0 tid=0x0000000003307800 nid=0x426c runnable"GC task thread#7 (ParallelGC)" os_prio=0 tid=0x0000000003308800 nid=0x4738 runnable"GC task thread#8 (ParallelGC)" os_prio=0 tid=0x000000000330a000 nid=0x19d4 runnable"GC task thread#9 (ParallelGC)" os_prio=0 tid=0x000000000330b000 nid=0x3af4 runnable"VM Periodic Task Thread" os_prio=2 tid=0x000000001b800000 nid=0x4338 waiting on conditionJNI global references: 317

从上面可以看到SATAUS_01线程的状态是TIMED_WAITING (sleeping)

STATUS_02 线程的状态是 WAITING (on object monitor) ，两者都叫阻塞

BLOCKED-DEMO-01 线程的状态是 TIMED_WAITING (sleeping) ，说明它抢到了锁并开始睡眠，BLOCKED-DEMO-02线程的状态是： BLOCKED (on object monitor) ，也是一种阻塞状态，因为BLOCKED-DEMO-02 和BLOCKED-DEMO-01都去抢占锁，但是BLOCKED-DEMO-01已经抢到了锁，BLOCKED-DEMO-02线程获取不到锁，因此是等待状态。

从上面的例子可以了解到了线程的生命周期，但线程的整个生命周期中并不是固定的处于某个状态，而是随着代
码的执行在不同的状态之间进行切换：

3.2 线程的启动

 public synchronized void start() {/*** This method is not invoked for the main method thread or "system"* group threads created/set up by the VM. Any new functionality added* to this method in the future may have to also be added to the VM.** A zero status value corresponds to state "NEW".*/if (threadStatus != 0)throw new IllegalThreadStateException();/* Notify the group that this thread is about to be started* so that it can be added to the group's list of threads* and the group's unstarted count can be decremented. */group.add(this);boolean started = false;try {start0();started = true;} finally {try {if (!started) {group.threadStartFailed(this);}} catch (Throwable ignore) {/* do nothing. If start0 threw a Throwable thenit will be passed up the call stack */}}}private native void start0();

查看Thread类的start()方法，发现它最终调用了一个本地方法start0() ,是一个在jvm层面的。Java中本质是没有线程的，那么Java代码中的创建一个线程，本质上是JVM 根据不同操作系统去调用对应的OS系统的创建线程的过程，过程如下：java代码中通过new Thread().start(）方法启动线程（直接调用Thread的run方法是调用实例方法，非启动一个线程），这个start()方法里面会调用一个C++语言编写的本地方法start0()，

start0()这个方法是在Thread 的静态块中来注册的：

registerNatives 的 本 地 方 法 的 定 义 在 文 件Thread.c,Thread.c 定义了各个操作系统平台要用的关于线程的公共数据和操作（Thread.c内容）
从上面可以看到start0() 实 际 会执 行的是JVM_StartThread 方法，这个方法定义在jvm.cpp 文件中（需要下载hotspot源码）：

JVM_ENTRY 是用来定义 JVM_StartThread 函数的，在这个函数里面创建了一个真正和平台有关的本地线程， JavaThread 的定义在 hotspot 的源码中 thread.cpp 文件中 1558 行的位置可以找到如下代码

这个方法有两个参数，第一个是函数名称，线程创建成功之后会根据这个函数名称调用对应的函数；第二个是当前进程内已经有的线程数量，os::create_thread,实际就是调用平台创建线程的方法来创建线程。接下来就是线程的启动，会调用 Thread.cpp 文件中的
Thread::start(Thread* thread)方法，代码如下

Thread::start(Thread* thread) 方法中有一个函数调用： os::start_thread(thread)，最终调用的是不同的操作系统平台启动线程的方法，最终会调用 Thread.cpp 文件中的 JavaThread::run()方法。

3.3 线程的终止

线程终止的条件：

• 线程run方法执行结束
• volatile jint _interrupted; // Thread.isInterrupted state
  线程正常情况下，不需要进行终止，只有一种情 况，线程的run方法中如果存在一个外界无法去终止的操作时，（如while循环，线程睡眠:Thread.sleep(200000)等， 线程睡眠虽然不占用CPU资源，但是线程也阻塞在那里，无法被执行），线程就无法结束，像下面代码中的这样，

public class InterruptDemo implements Runnable{private int i=1;@Overridepublic void run() {while(true){System.out.println("Test:"+i++);}}public static void main(String[] args) {Thread thread=new Thread(new InterruptDemo());thread.start();}
}

这种情况下，要终止线程，可以使用一个外部可以控制的boolean变量来作为while循环的条件，但是实际上并不这么做。java的线程中提功了一个方法Thread.currentThread().isInterrupted() ，它提供了一个共享变量isInterrupted作为中断的标记，默认为false，通过Thread.currentThread().isInterrupted() 可以去判断中断标记的状态：

   public boolean isInterrupted() {return isInterrupted(false);}/*** Tests if some Thread has been interrupted.  The interrupted state* is reset or not based on the value of ClearInterrupted that is* passed.*/private native boolean isInterrupted(boolean ClearInterrupted);

看下面这样一段代码，while循环中检测中断标记的状态值，主线程中通过 thread.interrupt() 来设置中断标记的值为true,使得线程能够被终止：

public class InterruptDemo01 implements Runnable{private int i=1;@Overridepublic void run() {
//        Thread.currentThread().isInterrupted()=false;
//        表示一个中断的标记  interrupted=faslewhile(!Thread.currentThread().isInterrupted()){System.out.println("Test:"+i++);}}public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(new InterruptDemo01());thread.start();Thread.sleep(1);//设置 interrupted=true;thread.interrupt();}
}

运行结果如下，注意看，左边run下面的按钮是绿色，表示程序执行结束了。

通过改变中断标记来让线程停止运行，也适用于线程阻塞的情况，如下代码：

public class InterruptDemo implements Runnable{private int i=1;@Overridepublic void run() {try {System.out.println("子线程开始睡眠3s");Thread.sleep(3000);System.out.println("子线程睡眠3s结束");} catch (InterruptedException e) {e.printStackTrace();}System.out.println("子线程结束运行");}public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(new InterruptDemo());thread.start();System.out.println("主线程开始睡眠1s");Thread.sleep(1000);System.out.println("主线程睡眠结束");thread.interrupt();System.out.println("主线程设置中断标记为true并结束运行");}
}

执行结果如下：

上面就是是两个通过线程中断 thread.interrupt() 来终止线程运行的例子；当其他线程通过调用当前线程的 interrupt 方法，表示向当
前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己；
针对线程阻塞的方法，要想去中断线程的执行，那么阻塞的方法必须抛出一个中断异常，表示线程响应了外部对他的中断，也就是说，当外部想要唤醒一个阻塞的线程时，线程只能通过抛出一个异常来表示它对中断的响应（凡是让线程阻塞的机制，都会有抛出一个InterruptedException才能够响应外界对线程的中断）。

• 线程复位
  ** 对 抛 出InterruptedException 异 常 的 方 法 ， 在InterruptedException 抛出之前，JVM 会先把线程的中断标识位清除，然后才抛出 InterruptedException，这个时候如果调用 isInterrupted 方法，将会返回 false**

• 线程终止原理
  thread.interrupt()方法：
  
  这个方法里面，调用了 interrupt0()，这个方法在前面分析start 方法的时候见过，是一个 native 方法，找到 jvm.cpp 文件，找到JVM_Interrupt 的定义
  
  这个方法直接调用了 Thread.cpp中的Thread::interrupt(thr)这个方法：
  
  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. 停止当前线程，并打印异常信息