目录

一、认识线程-Thread类

1、Thread类的常见构造方法

2、Thread 的几个常见属性

二、Thread类的基本用法

1、创建线程

方法一  继承 Thread 类

方法二  实现 Runnable 接口

方法三  使用匿名内部类

        匿名内部类创建 Thread 子类对象

        匿名内部类创建 Runnable 子类对象

方法四（最常用）  采用lambda表达式

2、启动线程        start()

（1）start()方法

（2）start()方法与run()方法的区别--代码演示

（3）start()方法与run()方法的区别--总结

2、线程中断        interrupt()

（1）给线程中设定一个结束标志位 isQuit

（2）注意 isQuit 的书写位置

（3）使用Thread类内置的标志位 isInterrupted()

（4）interrupt() 方法的作用

（5）为什么sleep()要清空标志位呢？

3、线程等待        join()

（1）join()方法，无参数

（2）join()方法，带参数

4、线程休眠        sleep()

5、获取线程实例        currentThread()

一个线程就是一个“执行流”。每个线程都可以按照顺序执行自己的代码，而多个线程可以 "同时" 执行多份代码。线程本身是操作系统中的概念。操作系统内核实现了线程这样的机制，并且对用户层提供了一些 API 供用户使用（例如 Linux 的 pthread 库）。而Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装。

Thread 类是 JVM 用来管理线程的一个类。在Java中，每个线程执行流都是通过Thread类的对象来描述的。JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理。

使用Thread类，我们可以创建和管理多个线程，并控制它们的执行顺序、优先级、暂停、恢复等。

Thread()  ：无参的构造方法。

Thread(Runnable target)  ：Runnable是一个接口类型。该构造方法需要一个Runnable类型的target参数。具体如何使用，在下文“创建线程”的部分会详细说明。

Thread(String name)  /  Thread(Runnable target, String name)：在创建线程的同时自定义一个线程对象名。这个操作相当于是给线程起了一个别名，方便后续查找辨认该线程，不影响程序的正常运行。不指定名称，系统也会给线程一个默认的名称。我们可以用 jconsole 工具来查看Java程序中的线程：

先用Java代码创建两个线程（如何创建线程仍然会在下文说明），并运行程序：

 在 jconsole 中可以看到：

这里的Thread-0，Thread-1就是系统默认给我们线程的命名。

此时，如果我们给线程 t1 指定一个name为"hello_t1"，再次用 jconsole 查看线程情况：

可见此时，t1 的名称就显示为我们自定义的"hello_t1"了。而 t2 未自定义命名，因此还是默认的名称。但是，起名只是方便标识，无论名称如何，都不影响程序的正常运行。

Daemon 表示一个后台进程（也叫守护进程）。.isDaemon()方法可以获得线程是前台进程还是后台进程。true表示是后台进程，false表示是前台进程。

.setDaemon()方法可以手动设置一个线程为前台线程或后台线程。具体演示如下：

如果我们将 t1.setDaemon(true) 语句删除，会怎样呢？此时t1就不再是后台进程，而是一个前台进程了，只有等到t1线程也结束，整个进程才会结束。但由于t1中有死循环，因此进程不会结束。

通过继承 Thread 类的方式来创建线程，主要分为 4 步：

具体代码演示如下：

程序运行结果： 

与上面的继承Thread类的方法类似，通过 Runnable 接口创建线程，主要有以下 4 个步骤：

 因此，我们直接在构造器的实参处，new一个实现了Runnable接口的类的实例即可。

包括该方法在内的所有创建线程的程序运行结果均同上。 

通过匿名内部类实现也有两种方式，一种是使用Thread的匿名内部类，另一种是使用Runnable的匿名内部类：

特别注意：Runnable匿名内部类以及大括号的书写位置。由于Runnable实例是要作为Thread构造方法参数传入的，因此Runnable的匿名内部类应当写在new Thread()的括号内。

查看Runnable接口的Java源码可以发现，Runnable接口是一个函数式接口。因此，我们可以通过lambda表达式来简便地创建一个线程。

start()方法是启动线程的方法，调用该方法会使线程进入就绪状态，等待CPU分配时间片后开始执行。run()方法是线程的执行体，它包含了线程要执行的代码；当调用start()方法启动线程后，线程会在独立的执行路径上自动执行run()方法中的代码（也就是说，当调用start()启动线程后，系统会自动调用run()方法执行线程的执行体）。

但要注意的是，run()方法并不标识新的线程的创建；调用 start 方法，才真的在操作系统的底层创建出了一个线程。

start()方法的使用：在创建完线程后，通过线程的实例调用start()即可。上面已经演示了很多，这里就不再多说。

事实上，也可以通过线程对象的实例调用run()方法：

但这两个方式有本质区别。

t1.start() 方法，才是真正创建了一个新的线程。当我们运行如下代码，可以看到，"i am t!"与"i am main!"两句交替打印，这时t1线程与main线程并发执行的结果，两个线程即不断打印"i am t!"和不断打印"i am main!"是同时执行的：

但当我们对比着执行下面的代码，会发现程序只打印了"i am t!"，并不打印"i am main!"。道理很简单：此时并没有创建出新的线程，打印"i am t!"与打印"i am main!"是同一线程中的先后关系。但由于打印"i am t!"是一个死循环，所以程序就卡在了这里，无法向下执行到打印"i am main!"了。

上述代码与下面这样写的实际运行效果相同：

由上面的代码演示可知：在调用start()方法启动线程后，系统会自动调用线程的run()方法；如果直接调用run()方法，那么线程不会启动，而是在当前线程中直接执行run()方法中的代码，这种情况下不会有新的线程产生。

因此，run()方法只是普通的方法调用，而start()方法则会创建一个新的线程并启动它，让它在新的线程中执行run()方法中的代码。正确使用start()方法可以实现并发执行多个任务，从而提高程序的性能。

概括来说有如下几点区别：

a. 作用功能不同：

run方法的作用是描述线程具体要执行的任务。

start方法的作用是真正的去申请系统线程。

b. 运行结果不同：

run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次；

start调用方法后, start方法内部会调用Java 本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段。

线程的中断就是字面意思：让一个线程停下来。也即线程的终止。（它与操作系统中的概念“中断”不是一个意思。）

本质上来说，让一个线程终止的唯一方法是让该线程的入口方法run()执行完毕。基于这个思路，我们可以尝试用以下的方式终止线程：

先创建一个线程 t ：

注意：该线程 t 的代码是死循环，死循环导致 t 的入口方法 run() 永远无法结束，因此该线程也永远不会结束。但，我们可以将循环条件用一个变量 isQuit 来控制。类似一个手动控制的开关，当 !isQuit 为true时，执行循环体内的逻辑；当 !isQuit 为false时则跳出。演示代码如下：

打印了3次"hello t!"后，!isQuit 被更改为了false。t 线程中的循环终止，打印"t 线程终止！！"后 t 线程结束。此时main线程也结束了，因此整个进程也随之结束，输出的运行结果如下：

这里的变量 isQuit 写作了成员变量。为什么不将 isQuit 写成 main 方法中的局部变量呢？

当我们尝试将 isQuit 写成 main 方法中的局部变量时，可以看到，出现了编译错误。

这个编译错误要特别说明：

有些同学可能认为，出现该编译错误是因为使用变量超出了它的作用域，但事实并非如此。线程 t 是可以正常拿到main线程中的变量的，因为同一进程的线程和线程之间共用内存地址空间，线程1创建出来的变量在线程2中也能访问（内存地址共用，变量也共用）。

正确的原因是变量捕获。lambda表达式能否访问它外面的局部变量？答案是可以，这里就涉及到了变量捕获这一语法规则。Java语法要求变量捕获，捕获到的变量必须是final或实际final(effectively final)。实际final指的是，虽然一个变量没有用final关键字修饰，但是代码中并没有尝试过修改它（没有做出过修改）。

在上面报错的代码中，我们在最后一行作出了修改isQuit的操作，这违背了变量捕获的语法要求，因此变量捕获失败了，程序编译报错。

解决方式就是按照一开始的，将isQuit写作成员变量，这样main中的程序访问成员变量就不受变量捕获规则的限制，也就不会存在上述问题了。

isInterrupted()就可以理解为，是t对象自带的一个结束标志位。通过 t.interrupt() 方法将t内部的标志位给设定成 true。

演示代码如下：

事实上，此时我们运行程序，并不会出现我们想要的线程中断的效果：

可以看到，当3秒钟时间到，调用 t.interrupt() 方法时，线程并没有终止，而是在打印了异常信息后，继续执行了。

运行结果中的这个异常信息，正是while循环中的catch捕获并打印的：

其实，interrupt() 方法不仅会改变线程内部的标志位，还会将sleep()唤醒。这是上述异常来源的原因。

interrupt()方法的作用：

换句话说，如果interrupt()执行时，t线程正在sleep，那么interrupt()在将标志位设置为true后，又会直接将sleep强行唤醒。sleep在该程序中，占据了绝绝绝大部分的时间，因此当interrupt()执行时，几乎一定会遇到正在sleep的情况。注意：当sleep被提前唤醒的时候，sleep会自动把isInterrupted标志位再次清空（即把true又变为false）。这就导致了下次再判断循环条件，循环条件还成立，因此循环还在继续执行。

这就好比有一天早上你关着灯拉着窗帘在床上睡大觉，本来你打算睡到8点，结果凌晨5点你妈妈就走进你的房间喊你起床，还把灯啪的一下给你打开了。你坐起来一看才5点，于是又随手把灯关了。

由于主线程只调用了一次interrupt()，因此在抛出一次异常后，后面就不会再次抛出异常了。

如果需要结束循环，则必须catch{}中，加一个break。

如图，实现了循环结束，线程终止。 

这么做的目的是为了让线程自身能够对于线程何时结束有一个更明确灵活的控制。

事实上，当前interrupt方法的效果并不是让线程立即结束，而是“通知建议”性质的，告诉线程“你该结束了”。至于线程是否真的要立即结束，都是可以通过代码来灵活控制的，否则就太僵硬了。interrupt只是通知，而不是命令。

比如有一天你正在打游戏，你的妈妈突然喊你去超市买酱油。这时你可以灵活选择：1、等一会儿再去；2、直接忽视；3、立马就去。代码也是一样：

线程t 何时结束，交给线程t 自己来决定。

对于如下代码，线程之间是并发执行的，操作系统对于线程的调度是无序的，无法判断两个线程谁先执行结束，谁后执行结束。先打印出"hello t!"还是"hello main!"，是无法确定的。

有些同学可能运行过代码后发现，结果总是先输出"hello main!"，再输出"hello t!"。这是因为线程t的创建也有一定的开销，这导致"hello t!"可能略慢一筹。但并不排除某些特定情况下，"hello main!"没有立即执行到。换句话说，即使大部分情况下先输出了"hello main!"，也无法判断下一次到底先输出哪个线程的运行结果。

这是一个并不受欢迎的问题。因为有的时候，就需要明确规定线程的结束顺序。这时，就可以通过线程等待join()来实现。 

在main线程中，我们调用t.join()，意思是让main线程等待 t 先结束，再往下执行，而别的线程不受影响。在 t.join() 执行的时候，如果 t 线程还没结束，main线程就会阻塞(Blocking)等待。可以理解为：代码走到这一行就停下来，当前线程就暂时不参与CPU的调度执行了。

此时，程序的输出结果就是确定的了，即先输出"hello t!"再输出"hello main!"

注意这里线程之间的等待关系：如果在 t1 线程中调用 t2.join()，就是让 t1 线程等待 t2 线程先结束（t1 进入阻塞，其它线程正常调度）。谁.join()，就等待谁；在谁中写 t.join() 这个语句，谁就阻塞等待。

这里的join()方法是无参的，它的效果是“死等”，“不见不散”；如果 t线程一直不结束，main线程就一直等待 t线程，直到等到为止。可以用如下代码演示：

join()方法还有一个版本，可以填写一个参数作为“超时时间”，也就是等待的最大时间。如果等待的时间已经到达了这个时间上限但还没等到，也就不等了。如以下代码演示：

有时也会有两个线程互相阻塞等待的情况，称之为“死锁”，是一种程序bug。 

sleep()线程休眠的方法前面已经使用过。需要注意的有两点，一是该方法是Thread类的一个静态方法，由Thread类名直接调用：Thread.sleep()；二是该方法存在一个受查异常，在使用这个方法时，需要try-catch或throw来处理这个异常。

前面我们也已经提到过了这个方法。它能获取当前线程对象的实例。在哪个线程里调用，得到的就是哪个线程对象的实例。需要的注意的是，该方法是Thread类的静态方法，由Thread类直接调用。