[Java]线程生命周期与线程通信

简介: 本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程,结合JDK1.8版本的特点进行了深入讲解。接着,通过多个实例介绍了线程通信的几种实现方式,包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。

【版权声明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
https://developer.aliyun.com/article/1631772
出自【进步*于辰的博客

线程生命周期与进程有诸多相似,所以我们很容易将两者关联理解并混淆,一些细节之处确有许多不同,因为线程调度与进程调度虽都由CPU完成,但两者并不相同。
特意耗费一些时间,系统地对线程生命周期与线程通信进行梳理、整理。
参考笔记三,P62、P63.1。

1、线程生命周期

1.1 JDK1.8版本

启发博文:《线程的生命周期及五种基本状态》(转发)。

引用其中一张线程生命周期图:

作者:代码の羁绊

在启发博文中,博主对线程五大状态和生命周期进行了很详细的说明,大家可以先行查阅。

这张图对线程生命周期总结得比较全面,我一一梳理、核对后觉得稍有不妥之处,略作修改后作如下图:

在这里插入图片描述

在此我先简述一下我对线程五个状态的理解:

  1. new(新建):在线程创建后、启动(start())之前所处的状态。
  2. Runnable(就绪):线程新建后并不是直接开始运行,而是被加入到等待队列,等待线程调度(等待CPU),此时就处于就绪状态。因此,这两种情况将进入就绪状态:(1)调用start();(2)因某种原因(如:线程通信、等待IO)进入阻塞状态后重新等待运行。
  3. Running(运行):线程正在运行时的状态。
  4. Blocked(阻塞):线程因某种原因(如:线程通信、等待IO)而停止运行后进入的状态。
  5. Dead(死亡):线程正常结束或异常终止后所处的状态。

相信大家在阅读完以上简述后,对线程的五大状态已经有了一个初步的认识,那状态间是如何转换的?又怎么理解呢?对于这两个问题,由于涉及到各个方法的业务和底层逻辑,本篇文章不便一一详述。如果大家想要进一步了解,可移步 → 《Thread类源码解析》。

其中,Blocked状态可能不太好理解,那位博主将其划分为三种情况:等待阻塞、同步阻塞和其他阻塞。我赞同,大家可移步启发博文查阅详述,在此不赘述,仅稍作说明:

三种阻塞情况的变动主要因“线程通信”引起,变化仅是阻塞情况的变化,状态不变,仍是Blocked

点出两个问题:
1:为什么调用notify()/notifyAll(),线程由等待Blocked变为锁定Blocked
文章排版考虑,在下文【使用Object类的wait()notify()】中说明。

2:interrupt()可中断线程,那么可中断正在阻塞的线程吗?
本质上说,可以,但会抛出异常(即不可以,故我未将其写入上图),在上文我给出的《Thread类源码解析》文章中有具体说明。

1.2 早期版本(JDK1.2之前)

相信能坚持阅读到这的博友,大部分是站在Java门槛上或刚入门不久的Java小白,你们现在了解和学习线程生命周期,获得的是已更新、迭代后的知识。个人认为,大家不需要掌握已过时的知识,但不能不了解,我先抛出两个问题:

  1. “挂起”状态是什么?怎么不在线程五大状态之列?
  2. 相信大家在一些资料中,可能见到过suspend()、resume()、stop()destroy()这4个方法,怎么上图中没有?为什么不用了?

当然是有的,只是过时了,所以没放上去,完整的图是这样:

在这里插入图片描述

OK,现在回答那两个问题。

“挂起”状态是一种类似Runnable(就绪)状态的状态,不同之处是进入就绪状态的线程,会释放所持有的“同步锁”,而“挂起”状态不会,“挂起”状态相当于“暂停”,故容易导致“死锁”。

为什么那4个方法会被放弃?
我寻得一答案,阐述得很详细,我便不班门弄斧了,看这里 → 《《Java面向对象编程》导读-Thread类的被废弃的suspend()、resume()和stop()方法》(转发)。

我补充一张图:
在这里插入图片描述

1.3 落到实处

所谓“落到实处”,就是要想掌握线程生命周期,光如上文夸夸其谈当然还不够,我们要把线程五大状态和状态间转换对应到Thread源码中才行。

如下图:

在这里插入图片描述

我自己感觉有点乱,源码所示如此。

当然,这不是完整图,图中状态间转换仅做了部分举例。在此,我不作说明,相信用心看到这里的博友可以大致理解。当然,也不便做出说明,因为我目前对一些方法的了解停留在“会用”的程度(见下文),并未对相应源码进行解析。

补充一点:
大家对比这张“状态图”和上文线程生命周期图,大家会发现有点对不上。

其实,WAITING就是Runnable(就绪),在线程生命周期中,一般不说“就绪”,“就绪”是进程生命周期中的术语,上文这般使用是为了方便大家理解;而RUNNABLE就是Running

2、线程通信

启发博文:《线程间通信的几种实现方式》(转发)。

我暂未整理“线程通信”相关理论,故下文将以示例的形式进行阐述。

注:以下5个示例都成功实现线程通信,输出结果是:

唤醒t1
t1已唤醒

2.1 使用 volatile 关键字

示例:

private static volatile boolean isWait = true;

public static void main(String[] args) {
   
    Thread t1 = new Thread(() -> {
   
        while (true)
            if (!isWait) {
   
                System.out.println("t1已唤醒");
                break;
            }
    });
    Thread t2 = new Thread(() -> {
   
        System.out.println("唤醒t1");
        isWait = false;
    });
    t1.start();
    t2.start();
}

如果大家不了解volatile关键字,看这里

这里线程通信利用的是volatile关键字“保证可见性”的原理。

2.2 使用Object类的wait()notify()

示例:

Object lock = new Object();
Thread t1 = new Thread(() -> {
   
    synchronized (lock) {
   
        try {
   
            lock.wait();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        System.out.println("t1已唤醒");
    }
});
Thread t2 = new Thread(() -> {
   
    synchronized (lock) {
   
        System.out.println("唤醒t1");
//      lock.notify();// 唤醒等待队列中的一个线程,不一定是 t1
        lock.notifyAll();
    }
});
t1.start();
t2.start();

大家还记得我在【1.1】中点出的这个问题吗?

为什么调用notify()/notifyAll(),线程由等待Blocked变为锁定Blocked

答案就在以上代码的执行过程中,我给大家捋一捋。

1、t1、t2都执行,t1在t2之前启动,先获得同步锁,t2阻塞。
2、t1调用wait()进入等待状态,释放同步锁,同步锁由t2获得,t2开始运行。
3、t2调用notify()唤醒t1,但此时同步锁仍由t2持有,t1继续等待。
4、t2运行完,释放同步锁,由t1获得,t1开始运行。

OK,就是第3点。

为什么一定要同步锁?
因为wait()notify()的底层逻辑要求必须是“先等待,再唤醒”,同步锁可以保证流程的正常执行。难道真的不能去掉同步锁?例如这样:

Object lock = new Object();
Thread t1 = new Thread(() -> {
   
    try {
   
        lock.wait();
    } catch (InterruptedException e) {
   
        e.printStackTrace();
    }
    System.out.println("t1已唤醒");
});
Thread t2 = new Thread(() -> {
   
    System.out.println("唤醒t1");
    lock.notifyAll();
});
t1.start();
t1.join();
t2.start();

很明显,不行。这样就出现了“死锁”。

t1 等待被唤醒,主线程等待 t1 运行完。

因此,必须使用同步锁,且必须是同一把锁(lock)、

2.3 使用JUC工具类 CountDownLatch

示例:

CountDownLatch latch = new CountDownLatch(1);// 这个 1 是同步状态,类似synchronized中的 count
Thread t1 = new Thread(() -> {
   
    try {
   
        latch.await();
    } catch (InterruptedException e) {
   
        e.printStackTrace();
    }
    System.out.println("t1已唤醒");
});
Thread t2 = new Thread(() -> {
   
    System.out.println("唤醒t1");
    latch.countDown();
});
t1.start();
t2.start();

可见,无需同步锁。为何?这就要涉及CountDownLatch类的源码了。当然,我们暂且不用深入了解,理解其底层逻辑即可。

看这里 → 《这一次,彻底搞懂Java中的synchronized关键字》(转发)。

大家找到【1.同步代码块】这一栏,底层逻辑相似。

2.4 使用 ReentrantLock 结合 Condition

示例:

Lock lock = new ReentrantLock();
Condition cond = lock.newCondition();

Thread t1 = new Thread(() -> {
   
    lock.lock();
    try {
   
        cond.await();
    } catch (InterruptedException e) {
   
        e.printStackTrace();
    }
    System.out.println("t1已唤醒");
    lock.unlock();
});
Thread t2 = new Thread(() -> {
   
    lock.lock();
    System.out.println("唤醒t1");
    cond.signal();
    lock.unlock();
});
t1.start();
t2.start();

这两条代码合起来相当于同步锁:

lock.lock();
...
lock.unlock();

2.5 使用 LockSupport

示例:

Thread t1 = new Thread(() -> {
   
    LockSupport.park();
    System.out.println("t1已唤醒");
});
Thread t2 = new Thread(() -> {
   
    System.out.println("唤醒t1");
    LockSupport.unpark(t1);
});
t1.start();
t2.start();

可见,LockSupport类不关注是否“在等待”。

最后

本文中的例子是为了方便大家理解和阐述知识点而简单举出的,旨在“阐明知识点”,简单为主,并不一定有实用性,仅是抛砖引玉。

如果大家想要快速地掌握这些知识点,我的建议是“自测中理解”。

本文完结。

相关文章
|
14天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
21天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
5天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
4天前
|
安全 Java 开发者
Java中的多线程编程:从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧,旨在帮助读者理解多线程的工作原理,掌握线程的创建、管理和同步机制。通过具体示例和最佳实践,本文展示了如何在Java应用中有效地利用多线程技术,提高程序性能和响应速度。
28 1
|
13天前
|
安全 Java 开发者
Java 多线程并发控制:深入理解与实战应用
《Java多线程并发控制:深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧,适合Java开发者深入学习和实践参考。
|
13天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档,本文以实战为导向,通过生动的实例和详尽的代码解析,引领读者领略多线程编程的魅力,掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者,本文都将为你打开多线程编程的新视角。 ####
|
12天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
18天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
45 9
|
15天前
|
安全 Java 开发者
Java多线程编程中的常见问题与解决方案
本文深入探讨了Java多线程编程中常见的问题,包括线程安全问题、死锁、竞态条件等,并提供了相应的解决策略。文章首先介绍了多线程的基础知识,随后详细分析了每个问题的产生原因和典型场景,最后提出了实用的解决方案,旨在帮助开发者提高多线程程序的稳定性和性能。
|
21天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####