Java 线程详解
一个程序至少需要一个进程，而一个进程至少需要一个线程，它也被称为主线程。
线程是程序执行流的最小单位，而进程是系统进行资源分配和调度的一个最小单位。
在单个进程中，可以拥有多个并发执行的线程，这些线程由CPU调度器分配时间片执行。
0. 线程的实现方式
使用 Thread 类的方式创建线程，写法简单，但不能在继承其他父类。
采用实现 Runnable、Callable 接口的方式创建线程，需要访问当前线程必须使用Thread.currentThread()，不过线程类知识实现了Runnable接口或者Callable接口，还可以继承其他类。多个线程还可以共享同一个target对象，体现了面向对象的思想，适合有设计思想的编程。
-
继承Thread类。并重写 run() 方法。
public class CustomThread extends Thread{ @Override public void run(){ //设计自定义的线程执行体 } } -
通过Runnable接口创建Thread类。
Thread t1 = new Thread(new Runnable(){ @Override public void run(){ //设计自定义的线程执行体 } }); //lambda表达式写法 Thread t1 = new Thread(()->{ //设计自定义的线程执行体 }); -
通过Callable和Future创建线程
- call()方法作为线程的执行体，带有返回值；
- 用 FutureTask 类来包装 callable 对象；
- 使用 FutureTask 类作为 Thread 对象的 target 创建并启动新线程；
- 可以通过 FutureTask 对象的 get() 方法来阻塞等待子线程执行结果。
public class CallableDemo implements Callable{ @Override public Object call() throws Exception{ //设计自定义的线程执行体 return res; } } public void callableTest(){ CallableDemo call = new CallableDemo(); FutureTask<Integer> futureTask = new FutureTask<Integer>(call); Thread t = new Thread(futureTask); t.start(); try{ //同步阻塞等待 //futureTask.get()阻塞等待线程执行结束返回结果 System.out.println("Result:"+futureTask.get()); }catch(Exception e){ e.printStackTrace(); } }
1. 常见方法
| 方法名 | 说明 | 补充 |
|---|---|---|
| start(): void | 启动一个线程，并由JVM调用线程中的 run() 方法 | 线程启动后，再次调用start()是不合法的 |
| run(): void | 线程要执行的具体任务的方法体 | 通过传入 Runnable 对象或者重写 run() 方法来定制线程任务 |
| sleep(long): void | 让线程睡眠指定时间 | 线程进入TIMED_WAITING线程状态，唤醒后，视线程调度情况而执行线程任务代码 |
| yield(): void | 译为“让步”，告知调度器该线程可以交出控制权 | yield()的让步通知可以被调度器（操作系统）忽略。如果让步成功，线程在Java层面将会保持运行态（RUNNABLE），但在操作系统层面，该线程将从 运行态 变为 就绪态 。 |
| interrupt(): void | 中断线程. 1. 如果中断的是阻塞态的线程，会清空打断状态（即认为没被打断过） 2. 如果中断的是正常运行的线程，会将打断状态设置为 true。 3. 只有在阻塞态被打断才会抛出异常。 | 1. 如果线程由 Object#wait(), join() 或者 sleep() 进入阻塞态，被中断时将抛出 InterruptedException 异常2. 如果线程在I/O阻塞态(java.nio)，I/O会被打断，并抛出 ClosedByInterruptException 异常3. 如果线程在Selector阻塞态(java.nio)，将会立即停止并返回 |
| interrupted(): boolean | 判断线程当前是否被中断 | 中断标志将会被清空！ |
| isInterrupted(): boolean | 判断线程当前是否被中断 | 不影响中断标志 |
2. 线程状态
2.1 操作系统线程的五大状态
- 初始态(New): 线程对象被创建后，进入初始态，也叫做新建状态。
- 就绪态(Runnable): 线程已启动，随时可以被 CPU 调度执行。进入就绪态的情况：
- 运行态–>就绪态：运行态线程由于时间片使用完而被动让出CPU使用权，或者主动让出 CPU 使用权。
- 阻塞态–>就绪态：阻塞结束，线程被唤醒，进入就绪态。
- 运行态(Running):线程获取CPU时间片并执行。线程只能从就绪态进入运行态。
- 阻塞态(Blocked):线程因为某种原因放弃 CPU 使用权，暂时停止运行，直到线程进入就绪态，才有机会转到运行态。在Java中阻塞有三种情况：
- 等待阻塞——调用线程对象的 wait() 方法，阻塞调用者线程并让出 CPU 使用权，直到被该作为锁的线程对象调用其 notify() 方法。（见Java的 Object#wait() #notify() #notifyAll() 方法）
- 同步阻塞——线程获取锁失败，进入同步阻塞状态。
- 其他阻塞——线程调用 sleep() 或者 join() 或者发出 I/O 请求，进入阻塞状态。当 sleep(long) 状态超时、join() 等待线程终止或者超时，或者 I/O 处理完毕，线程可重新进入就绪状态。
- 死亡态(Dead):线程任务执行完毕，线程结束生命周期。
2.2 Java线程的六大状态
-
初始状态(NEW)：通过 new 关键字新建一个线程。注意，此时的线程只是一个普通的对象引用，操作系统并未创建新的线程。 在构造方法中，仅对线程对象赋予一些属性变量。
-
运行状态(RUNNING): 线程调用 start() 方法，从初始状态进入就绪状态。此时才真正由操作系统创建一个线程。Java并不能区分线程处在操作系统中的运行态还是就绪态，JVM 将两种状态统一标记为运行态。（在操作系统中对应为 初始态 ，就绪态 与 运行态 ）
- 运行中–>就绪态：yield() 方法主动让出 CPU 使用权
- 就绪态–>运行中：系统分配给该线程 CPU 时间片
-
等待状态(WAITING): 该状态表示当前线程需要等待其他线程做出一些特定动作。（在操作系统中对应为 阻塞态 ）
- 调用 Object#wait() 方法，调用者让出 CPU 使用权，进入等待状态，直到 锁对象调用 Object#notify() 或者 Object.notifyAll() 唤醒。
- 在线程执行过程中，调用了其他线程的 join() 方法，需要进入等待状态，阻塞地等待其他线程执行完毕，才可继续当前线程的后续任务。
- 通过 LockSupport.park() 方法将当前线程阻塞挂起，进入等待状态， 直到 LockSupport.unpark(thread) 唤醒线程并等待被调度。
-
超时等待状态(TIMED_WAITING): 与 WAITING 不同的是，它可以在指定时间内自行返回。（在操作系统中对应为 阻塞态 ）
-
通过 Thread.sleep(long) 方法，或者` Object#wait(long) , Object#join(long) 方法进入限时等待状态，如果超过设定时间还未进入运行状态，将会被主动取消阻塞状态，进入运行状态。
（需要注意的是，虽然进入JVM的 运行态（RUNNABLE），但实际在操作系统中，是进入就绪状态（）Runnable），等待被调度。）
-
-
阻塞状态(BLOCKED): 表示当前线程正在等待 Monitor锁（重量级锁）。（在操作系统中对应为 阻塞态 ）
-
线程等待进入 synchronized 修饰的临界区。线程获取到锁，就会从阻塞状态进入运行态。
（需要注意的是，虽然进入 JVM 的运行态(RUNNABLE)，但实际在操作系统中，是进入就绪状态(Runnable)，等待被调度。）
-
-
终止状态(TERMINATED): 表示线程的 run() 和 call() 已经执行完毕。不能通过 start() 再次唤醒。
3. start() vs run()
start() 方法让操作系统创建并启动一个线程，使得该线程进入操作系统的就绪态。在Java中，进入到运行态。（Java不区分操作系统中的就绪态与运行态）
run() 方法是线程的任务体，它需要被操作系统调用，而不应该由用户主动调用。如果由用户主动调用，run() 方法将会被作为一个普通方法，在调用者的线程中执行，而不是开辟一个新的线程执行它。
可以通过重写 run() 方法，或者初始化线程对象时传入 Runnable 对象，进行线程任务的设计。Thread # run() 源码如下：
//Thread类 实现了 Runnable接口
@Override
public void run(){
//如果初始化Thread类的时候，传入了Runnable实例，即target，且run()方法并未被重写，则会调用target的run()方法
if(target != null){
target.run();
}
}
4. sleep() vs yield()
主要区别：
- 在操作系统层面，sleep() 后进入阻塞态，yield() 后进入就绪态。
- 在 JVM 层面， sleep() 后进入限时等待状态， yield() 后保持运行态。
sleep(long) 方法：
- 让 Java 线程从 运行态（RUNNABLE），进入 限时等待状态（TIMED_WAITING）。
- 别的线程可以通过 interrupt() 打断进入 限时等待状态（TIMED_WAITING） 的线程。被打断的线程将会抛出
InterruptedException异常。异常捕获后，进入 运行态（RUNNABLE），实则进入操作系统层面等待被调度的就绪态。 - 被唤醒后未必立即执行（唤醒后进入操作系统层面的就绪态，等待被 CPU 调度）
yield() 方法：
- Java线程状态不变，仍在 运行态（RUNNABLE），实则主动让出 CPU 使用权，在操作系统层面，从运行态进入就绪态。
- 这是一个 native 方法，具体实现依赖于操作系统的调度器。注意，它让出 CPU 使用权的请求可以被 CPU 调度器忽略。
sleep()和yield()的应用
- 让线程放弃 CPU 使用权，当没有利用 CPU 做计算时，可以防止 CPU 空转而浪费资源。
- 可以让线程等待指定时间后继续执行任务。
5. join() 的实现原理
join() 方法主要是为同步等待另一个线程执行结束。使用如下：
public void joinTest(){
Thread t1 = new Thread(()->{...});
//在当前线程中，开启一个t1线程
t1.start();
//调用t1线程的join方法，当前线程将会阻塞在此，等待t1线程执行结束
t1.join();
//t1线程执行结束，才会继续执行下面的代码
...
}
join() 主要使用 while(isAlive())进行等待，核心代码如下：
public final synchronized void join(long millis){
while (isAlive()) {
wait(0);
}
}
join() 由 synchronized 修饰。假设 A 线程调用了B线程的 join() 方法，当 A 线程获取到 B 线程的锁后，调用 wait(0) 方法，从而进入无限期等待,即等待状态（WAITING）。
这里可能有人有误解，为什么我调用的是线程 B 的 wait() 方法，但线程 A 进入了无限期等待？
答： 因为这里可以理解为在线程 A 中进行了如下调用：
//这是在线程A中调用了线程B的join方法和wait()方法，虽然调用的是线程B对象的方法，但是上下文环境为线程A， synchronized(threadB){ while(threadB.isAlive()){ threadB.wait(0); } }而wait() 方法会让调用者所在线程进入等待状态。在线程 A 中调用了线程 B 的 join() 方法和 wait(0) 方法，虽然调用的是线程 B 对象的方法，但是上下文环境为线程 A ，
只有在线程 B 的 run() 方法中调用的方法，执行方法所在的线程才认为是线程 B
当一个线程执行完时，系统会调用其 exit() 方法，并在其中执行 notifyAll()。所以当线程B执行完毕后，线程A可以被唤醒。
while(isAlive()) 循环判断的意义：一直判断，直到B线程启动。线程对象调用 start() 方法后需要操作系统创建并启动线程，需要时间。
6. interrupt()
interrupt() 的主要任务是通知中断。
- 如果线程处于阻塞态，如通过
sleep(),wait()等方法，或者正在I/O阻塞状态，那么interrupt()后，该线程会接收到一个异常。
可以通过try / catch中捕获到的异常，判断打断后程序是要终止还是继续运行。 - 如果线程是正常运行状态，将会把中断状态设置为 true 。不会影响run()中程序的正常执行，仅知道了"interrupt status == true" 而已。
可以通过中断标志这个 boolean 值，判断程序是终止还是继续运行。 - 如果该线程并不存活，如还未进入运行态，或者已经进入终止态，不会有任何影响。
- 通过
LockSupport.part()阻塞挂起的线程，可以被中断退出阻塞状态，回到就绪态，同时中断标记被interrupt()设置为 true 。如果中断标记为真，线程的LockSupport.park()方法将会失效。
想要恢复 park()功能，就要通过interrupted()来清空打断标记
虽然 LockSupport.park() 和 wait(0) , join() 等方法一样 ，让Java线程进入 等待状态（WAITING），但不同的是，被中断 interrupt() 后，不会抛出异常。示例代码：
public static void main(String[] args) throws InterruptedException {
//初始化一个名为t1的线程
Thread t1 = new Thread(()->{
System.out.println(Thread.currentThread().getName()+": begin run()");
try{
LockSupport.park();
}catch (Exception e){
System.out.println(e.getMessage());
}
System.out.println("t1's status = "+Thread.currentThread().getState());
System.out.println(Thread.currentThread().getName()+": continue run() after park()");
},"t1");
System.out.println(Thread.currentThread().getName()+" :begin t1.start()");
t1.start();
System.out.println("t1's status = "+t1.getState());
System.out.println(Thread.currentThread().getName()+" :begin sleep");
//这里的等待是为了保证t1进入运行态，且执行了LockSupport.park()方法
Thread.sleep(5000);
System.out.println("t1's status = "+t1.getState());
System.out.println(Thread.currentThread().getName()+" :begin t1.interrupt()");
t1.interrupt();
}
上述程序运行结果为：
main :begin t1.start()
t1's status = RUNNABLE
main :begin sleep
t1: begin run()
t1's status = WAITING //LockSupport.park()方法让Java线程进入到WAITING状态（在操作系统层面为阻塞态）
main :begin t1.interrupt()
t1's status = RUNNABLE //中断后，回到了RUNNABLE状态，且没有抛出异常
t1: continue run() after park() //继续run()后续代码的执行
Process finished with exit code 0
我们可以发现，interrupt() 后， LockSupport.park() 方法并不会抛出异常，而是继续程序执行。
interrupted() vs isInterrupt()
interrupted(): 返回打断标记，并清除打断标记（将打断标记设为false)isInterrupted(): 返回打断标记
扫一扫
2101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
