JUC从入门到成神（基础篇）- 关于Java线程

👏作者简介：大家好，我是笙一，java大二练习生，喜欢算法和java相关知识。

📕正进行的系列：算法 、JUC从入门到成神

目录

线程的创建和运行

Thread 直接创建

Thread 配合 Runnable

Thread 配合 FutureTask

线程运行原理

栈、栈帧

上下文切换

常见方法

start 和 run

sleep 和 yield

 join

interrupt

不推荐使用的方法

主线程和守护线程

五种线程状态

六种线程状态

重新理解线程状态转换

---

线程的创建和运行

Thread 直接创建

//构造方法的参数是给线程指定名字
Thread t1 = new Thread("t1"){
    @Override
    //run方法内实现了要执行的任务
    public void run(){
        log.debug("线程1");
    }
};
t1.start();

Thread 配合 Runnable

 核心概念就是把 “任务” 和 “线程” 分开

// 任务对象
Runnable r1 = new Runnable(){
    @Override
    public void run(){
        log.debug("任务");
    }
};

// 参数1 ：任务对象
// 参数2 ：线程名字
Thread t1 = new Thread(r1, "t1");
t1.start();

        此过程也可以使用lambda进行简化：

Runnable r1 = () -> log.debug("任务");
Thread t1 = new Thread(r, "t1");
t1.start();

Thread 配合 FutureTask

如果任务有返回值，那么就用此方法，因为FutureTask可以接收Callable类型的参数，以此处理有返回结果的情况

// 创建任务
FutureTask<Integer> f = new FutureTask<>(() -> {
    log.debug("hello");
    return 100;
});

// 参数1 ：任务对象
// 参数2 ：线程名字
Thread t1 = new Thread(f, "t1");
t1.start();

// 此时主线程会阻塞，同步等待f执行完毕的结果
Integer result = f.get();
log.debug("结果是:{}", result);

线程运行原理

栈、栈帧

全名Java Virtual Machine Stacks（Java虚拟机栈）

JVM中由堆，栈，方法区所组成，其中的栈内存给线程用，每个线程启动后，虚拟机就会为其分配一块栈内存。我们了解到：

• 每个栈由若干个栈帧（Frame）组成，每个栈帧对应着每次方法调用时所占的内存

• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

上下文切换

我们经常因为以下原因使得当前cpu调用的线程不再运行：

• 线程的cpu时间片用完

• 垃圾回收

• 有更高优先级的线程需要运行（在一些操作系统中，可能会存在抢占式调度（Preemptive Scheduling）的机制，即使一个线程正在执行，如果有更高优先级的线程需要执行，操作系统也会中断当前线程的执行，切换到更高优先级的线程。这样可以确保高优先级任务能够尽快得到响应，提高系统的响应性和效率。）

• 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法

这个时候就会进行上下文切换，cpu分配时间片转去执行别的线程。当上下文切换发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等

• 上下文切换频繁发生会影响性能

常见方法

方法名	功能说明	注意
start()	启动一个新线程，在新的线程运行run方法中的代码	start方法只是让线程进入就绪，里面代码不一定立刻运行（CPU的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次就会出现 IllegalThreadStateException
run()	新线程启动后会调用的方法	如果在构造Thread对象时传递了Runnable参数，则线程启动后会调用Runnable中的run方法，否则默认不执行如何操作。但可以创建Thread的子类对象，来覆盖默认行为
join()	等待线程运行结束
join(long n)	等待线程运行结束，最多等待n毫秒
getId()	获取线程长整型的id	id唯一
getName()	获取线程名
setName(String)	修改线程名
getPriority()	获取线程优先级
setPriority(int)	修改线程优先级	java中规定线程优先级是1~10的整数，较大的优先级能提高该线程被CPU调度的机率
getState()	获取线程状态	Java中线程状态是用6个enum表示，分别为：NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED
isInterrupted()	判断是否被打断	不会清除打断标记
isAlive()	判断线程是否存活（还没有执行完毕）
interrupt()	打断线程	如果被打断线程正在sleep，wait，join会导致被打断的线程抛出InterruptedException，并清除打断标记；如果打断的正在运行的线程，则会设置打断标记；pack的线程被打断，也会设置打断标记
interrupted() static	判断当前线程是否被打断	会清除打断标记
currentThread() static	获取当前正在执行的线程
sleep(long n) static	让当前执行的线程休眠n毫秒，休眠时让出cpu的时间片给其他线程
yield() static	提示线程调度器让出当前线程对CPU的使用	主要是为了测试和调试

start 和 run

调用run

public static void main(String[] args){
    Thread t1 = new Thread("t1"){
        @Override
        public void run(){
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    
    t1.run();
    log.debug("do other things...");
}

当你直接调用 run() 方法时，它会在当前线程中执行，而不会创建新的线程，所以当前程序仍在main线程运行，FileReader.reader()方法调用还是同步的。

所以要使用start()去启动新线程才行

sleep 和 yield

sleep

1.调用sleep会让当前线程从Running进入Timed Waiting状态（阻塞）

2.其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时sleep方法会抛出 InterruptedException

3.睡眠结束后的线程未必会立刻得到执行

4.建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

1.调用yield会让当前线程从Running进入Runnable状态，然后调度执行其它同优先级的线程。如果这时没有同优先级的线程，那么不能保证让当前线程暂停的效果

2.具体的实现依赖于操作系统的任务调度器

线程优先级

• 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

• 如果cpu比较忙，那么优先级高的线程会获得更多的时间片，但cpu闲时，优先级几乎没作用

sleep实现 - 防止CPU占用100%

在没有利用cpu来计算时，不要让while(true)空转浪费 cpu，这时可以使用yield或sleep来让出cpu的使用权给其他程序

while(true){
    try{
        Thread.sleep(50);
    }catch(InterruptedException e){
        e.printStackTrace;
    }
}

• 可以使用wait或条件变量达到类似的效果

• 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景

• sleep适用于无需锁同步的场景

 join

为什么需要join

下面的代码执行，打印 r 是什么

static int r = 0;
public static void main(String[] args) throws InterruptedException{
    test1();
}
private static void test1() throws InterruptedException{
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);   //这里的sleep视为睡眠1秒
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为：{}",r);
    log.debug("结束");
}

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要1秒之后才能算出r=10

• 而主线程一开始就要打印r 的结果，所以只能打印出 r = 0

解决方法

• 用sleep行不行，为什么？

  答：不行，因为你不知道t1执行完毕需要多久，所以无法把握主线程需要sleep多久

• 用join，加在 t1.start() 之后即可

了解了上述的知识，我们来看看一个有意思的案例

static int r1 = 0;
static int r2 = 0;
private static void test2() throws InterruptedException{
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    Thread t2 = new Thread(() -> {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    log.debug("join begin");
    t1.join();
    log.debug("t1 join end");
    t2.join();
    log.debug("t2 join end");
    long end = System.currentTimeMillis();
    log.debug("r1:{} r2:{} cost:{}", r1, r2, end - start);
}

我们最好得到的日志包括：10，20，2001（可变，但接近2000）

这是因为，在 t1.join() 时，即使我们在主线程中进行等待，但此时 t2 仍然在 并行/并发 运行，所以最后的时间仍然是 t2 的时间（t1 运行完了后，t2 也只剩下了1秒）。

有时效的join

static int r = 0;
public static void main(String[] args) throws InterruptedException{
    test1();
}
private static void test1() throws InterruptedException{
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(2);   //这里的sleep视为睡眠1秒
        log.debug("结束");
        r = 10;
    });
    t1.start();
    t1.join(1500);  //没等够时间
    log.debug("结果为：{}",r);
    log.debug("结束");
}

所以r为0

但如果join的时间大于 t1 运行时间，会提前结束join

interrupt

打断sleep，wait，join的线程

这些是阻塞状态线程

打断sleep的线程，会清空打断状态，以sleep为例

private static void test1() throws InterruptedRxception{
    Thread t1 = new Thread(() -> {
        sleep(1);
    }, "t1");
    t1.start();
    
    sleep(0.5); //防止打断操作先于t1执行
    t1.interrupt();
    log.debug("打断状态：{}", t1.isInterrupted());   
}

输出 - 打断状态：false

打断正常运行的线程

打断正常运行的线程，不会清空打断状态

private static void test2() throws InterruptedException{
    Thread t2 = new Thread(() -> {
        while(true){
            Thread current = Thread.currentThread();
            boolean interrupted = current.isInterrupted();
            if(interrupted){
                log.debug(" 打断状态：{}", interrupted);
                break;
            }
        }
    }, "t2");
    t2.start();
    
    sleep(0.5);
    t2.interrupt();
}

输出

20:57:37.964 [t2] c.TestInterrupt -  打断状态：true

其实如果我们没有在while循环里面手动结束（if操作），它会一直运行下去。这是因为正常运行的线程被打断，只是改变了打断标记，我们需要利用打断标记去手动停止循环。

主线程打断t2只是告诉t2要被打断，而实际被打断的线程是由自己来决定运行还是停止运行

再举个例子：

public class MyThread extends Thread {
    public void run() {
        while (!isInterrupted()) {
            try {
                // 执行任务
                Thread.sleep(1000); // 假设这里是一个耗时操作
            } catch (InterruptedException e) {
                // 捕获InterruptedException异常，响应中断请求
                System.out.println("Thread interrupted. Exiting...");
                // 清理资源等工作
                return; // 终止线程执行
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        // 主线程等待一段时间后中断子线程
        try {
            Thread.sleep(5000);
            thread.interrupt(); // 发送中断请求
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，子线程 MyThread 在执行任务时会不断检查自身的中断状态，如果被中断了就会捕获 InterruptedException 异常，并在异常处理代码中终止执行。在主线程中，我们等待了5秒后中断了子线程。

1. 线程在while循环条件判断之前被中断：在这种情况下，线程会跳过while循环并执行后续代码，不会进入catch块，也不会输出 "Thread interrupted. Exiting..." 这一行。

2. 线程在while循环内部被中断：在这种情况下，线程会捕获InterruptedException异常，进入catch块处理中断请求，并输出 "Thread interrupted. Exiting..." 这一行。

所以interrupt只是改变了目标的打断状态，不能真正打断该线程，如需打断，需手动操作。

两阶段终止模式

在一个线程T1中如何“优雅”终止线程T2？这里的【优雅】指的是给T2一个料理后事的机会。

1.错误思路

• 使用线程对象的stop（）方法终止线程

  • stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没用机会释放锁，其它线程将永远无法获取锁

• 使用System.exit(int)方法停止线程

  • 目的仅是停止一个线程，但这种做法会让整个程序都停止

2.正确方法

class TwoPhaseTermination{
    private Thread monitor;
    
    //启动监控线程
    public void start(){
        monitor = new Thread(() -> {
            while(true){
                Thread current = Thread.currentThread();
                if(current.isInterrupted()){
                    log.debug("料理后事");
                    break;
                }
                try{
                    Thread.sleep(1000);     //被打断情况1
                    log.debug("执行监控记录");    //被打断情况2    
                }catch(InterruptedException e){
                    e.printStackTrace();
                    //重新设置打断标记
                    current.interrupt();
                }
            }
        });
        monitor.start();
    }
    //停止监控线程
    public void stop(){
        monitor.interrupt();
    }
}

打断park线程

打断park线程，不会清空打断状态

private static void test3() throws InterruptedException{
    Thread t1 = new Thread(() -> {
        log.debug("park...");
        LockSupport.park();
        log.debug("unpark...");
        log.debug("打断状态:{}",Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    
    sleep(1);
    t1.interrupt();
}

输出 - 21:11:52.795 [t1] c.TestInterrupt - park...
          21:11:53.295 [t1] c.TestInterrupt - unpark...
          21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

不推荐使用的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

方法名	static	功能说明
stop()		停止线程运行
suspend()		挂起（暂停）线程运行
resume()		恢复线程运行

主线程和守护线程

默认情况下，Java进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
    log.debug("开始运行...");
    sleep(2);
    log.debug("运行结束...");
}, "daemon");
//设置该线程为守护线程
t1.setDaemon(true);
t1.start();

sleep(1);
log.debug("运行结束...");

输出

08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束...

注意：

• 垃圾回收器线程就是一种守护线程

• Tomcat中的Acceptor和Poller线程都是守护线程，所以Tomcat接收到shutdown命令后，不会等待它们处理完当前请求

五种线程状态

这是从 操作系统 层面来描述的

• 【初始状态】仅是在语言层面上创建了线程对象，还未与操作系统线程关联

• 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由CPU调度执行

• 【运行状态】指获取了CPU时间片运行中的状态

  • 当CPU时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换

• 【阻塞状态】

  • 如果调用了阻塞 API ，如 BIO 读写文件，这时该线程实际不会用到CPU，会导致线程上下文切换，进入【阻塞状态】

  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】

  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

• 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

六种线程状态

这是从Java API 层面来描述的

根据 Thread.State 枚举，分为六种状态

1. NEW（新建）：当线程对象被创建时，它处于新建状态。在调用start()方法之前，线程处于这个状态。

2. RUNNABLE（可运行）：一个可运行的线程处于正在执行的状态，或者正在等待系统分配处理器资源的状态。一个线程可以从可运行状态转变为运行状态，例如当调用了start()方法，或者处于等待某个锁的状态并且获得了该锁。

3. BLOCKED（被阻塞）：线程处于阻塞状态，表示线程正在等待锁的释放以进入同步块/方法。当一个线程尝试获取一个锁，而该锁被其他线程持有时，线程会被阻塞。

4. WAITING（等待）：线程处于等待状态，表示线程无限期地等待另一个线程执行某个特定操作。例如，通过调用Object.wait()、Thread.join()方法，或者等待某个条件的成立等。

5. TIMED_WAITING（计时等待）：线程处于等待状态，但是有一个时间限制，即线程等待一段指定的时间。例如，通过调用Thread.sleep()、Object.wait(long)、Thread.join(long)等带有超时参数的方法。

6. TERMINATED（终止）：表示线程已经执行完毕，已经退出。一个线程可以处于终止状态是因为它正常执行完了run()方法，或者因为出现了异常而导致run()方法提前结束

重新理解线程状态转换

学完 wait/notify，pack/unpack 后的重新审视

假设有线程Thread t

情况1 NEW --> RUNNABLE

• 当调用 t.start() 方法时，由 NEW --> RUNNABLE

情况2 RUNNABLE <--> WAITING

t 线程用 sychronized（obj）获取了对象锁后

• 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING

• 调用 obj.notify() ，obj.notifyAll()，t.interrupt() 时

  • 竞争锁成功，t 线程从 WAITING --> RUNNABLE

  • 竞争锁失败，t 线程从 WAITING --> BLOCKED

情况3 RUNNABLE <--> WAITING

• 当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING

  • 注意是当前线程在 t 线程对象的监视器上等待

• t 线程运行结束，或调用了当前线程的 interrupt（）时，当前线程从 WAITING --> RUNNABLE

情况4 RUNNABLE <--> WAITING

• 当前线程调用 LockSupport.pack() 方法会让当前线程从 RUNNABLE --> WAITING

• 调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt()，会让目标线程从 WAITING --> RUNNABLE

情况5 RUNNABLE <--> TIMED_WAITING

t 线程用 synchronized(obj) 获取了锁对象后

• 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING

• t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ，obj.notifyAll()，t.interrupt() 时

  • 竞争锁成功，t 线程从 TIME_WAITING --> RUNNABLE

  • 竞争锁失败，t 线程从 TIME_WAITING --> BLOCKED

情况6 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIME_WAITING

  • 注意是当前线程在 t 线程对象的监视器上等待

• 当前线程等待时间超过了 n 毫秒，或 t 线程运行结束，或调用了当前线程的 interrupt（）时，当前线程从 TIME_WAITING --> RUNNABLE

情况7 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 Thread.sleep(long n)，当前线程从 RUNNABLE --> TIMED_WAITING

• 当前线程等待时间超过了 n 毫秒，当前线程从 TIME_WAITING --> RUNNABLE

情况8 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis)时，当前线程从 RUNNABLE --> TIMED_WAITING

• 调用 LockSupport.unpark(目标线程)或调用了线程的 interrupt()，或是等待超时，会让目标线程从 WAITING --> RUNNABLE

情况9 RUNNABLE <--> BLOCKED

• t 线程用 synchronized（obj）获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED

• 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果 t 线程竞争成功，从 BLOCKED --> RUNNABLE，其它失败的线程仍然 BLOCKED

情况10 RUNNABLE <--> TERMINATED

当线程所有代码运行完毕，进入TERMINATED

小注意点：RUNNABLE的阻塞状态是因为阻塞API导致的，如等待IO操作。而BLOCKED的阻塞是由于未竞争到锁导致的。