线程的生命周期和常用方法

最新推荐文章于 2025-03-02 01:21:09 发布
最新推荐文章于 2025-03-02 01:21:09 发布
阅读量80 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45017958/article/details/130765247
版权
本文介绍了Java线程的生命周期，包括NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED六种状态，并通过代码示例展示了线程在不同状态间的转换。同时，详细讲解了wait、notify、notifyAll、sleep和join等线程控制方法的使用及原理，以及它们在生产者-消费者模式中的应用。
摘要由CSDN通过智能技术生成

线程的生命周期和常用方法

生命周期

根据jdk官方文档，线程状态有以下几种

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

如图示所见

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MwwxQ9DG-1684475551693)(null)]

代码演示

NEW / TIMED_WAITING / TERMINATED
package ThreadMethod;

import java.util.concurrent.TimeUnit;

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                

            }


        });
        System.out.println("线程状态："+ thread.getState());
        thread.start();
        Thread.sleep(2000);
        System.out.println("线程状态：" + thread.getState());
        Thread.sleep(2000);
        System.out.println("线程状态：" + thread.getState());

    }


}
结果
线程状态：NEW
线程状态：TIMED_WAITING
线程状态：TERMINATED
线程状态：TERMINATED
WAITING / BLOCKED
package ThreadMethod;

public class BlockThreadState implements Runnable {

    static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {

        BlockThreadState blockThread = new BlockThreadState();
        Thread thread = new Thread(blockThread);
        System.out.println("thread state : " + thread.getState());
        thread.start();
        Thread.sleep(20);
        System.out.println("thread state : " + thread.getState());
        synchronized (lock){
            lock.notify();
        }
        System.out.println("thread state : " + thread.getState());
        Thread.sleep(20);
        System.out.println("thread state : " + thread.getState());

    }



    @Override
    public void run() {
        try {
            synchronized (lock){
				// wait状态
                lock.wait();
                // synchronized重新拿到锁 处于block状态
                for (int i = 0; i < 1000000000; i++) {
                    continue;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
结果
thread state : NEW
thread state : WAITING
thread state : BLOCKED
thread state : TERMINATED

常见方法

wait()

wait()方法执行后，会阻塞线程，同时释放锁，如果想要唤醒该线程，则需要以下条件

  • 另一个线程调用这个对象的notify()方法，且刚好被唤醒的时本线程
  • 另一个线程调用了这个对象的notifyAll()方法
  • 过了wait(long timeout) 规定的超时时间，如果传入0就是永久等待
  • 线程自身调用了interrupt()

PS： 使用wait()方法时，必须先拥有monitor锁, 也就是说wait方法需要放在同步代码块中执行

notify/notifyAll

notify/notifyAll用于唤醒线程，当另一个线程调用wait()进入 waitting状态时，另一个线程调用notifyAll()可唤醒当前线程（如果有多个线程，使用notify并不一定能够唤醒线程）

组合使用示例

public class BlockThread {
    public static void main(String[] args) {
        Message message = new Message();

        // 创建一个等待线程
        Thread waitThread = new Thread(new WaitThread(message));
        // 创建一个唤醒线程
        Thread notifyThread = new Thread(new NotifyThread(message));

        // 启动等待线程和唤醒线程
        waitThread.start();
        notifyThread.start();
    }
}

// 共享的消息类
class Message {
    private boolean isReady = false;

    // 等待方法
    public synchronized void waitForMessage() {
        while (!isReady) {
            try {
                // 当消息不可用时，线程进入等待状态
                System.out.println("线程进入等待状态");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 执行到这里表示收到消息，进行处理
        System.out.println("收到消息！");
    }

    // 唤醒方法
    public synchronized void sendMessage() {
        // 做一些准备工作，例如获取消息

        // 唤醒等待的线程
        isReady = true;
        System.out.println("唤醒等待的线程");
        notify();
    }
}

// 等待线程
class WaitThread implements Runnable {
    private Message message;

    public WaitThread(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        // 等待消息
        message.waitForMessage();
    }
}

// 唤醒线程
class NotifyThread implements Runnable {
    private Message message;

    public NotifyThread(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        // 发送消息
        message.sendMessage();
    }
}

/*

线程进入等待状态
唤醒等待的线程
收到消息！

Process finished with exit code 0
*/

图示 monitor锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3seWziw5-1684475551650)(null)]

  • Entry Set 入口集
    • 线程进入后抢锁
  • The owner 锁持有线程
    • 如果方法没有执行完之前没有释放锁，则程序正常退出并释放锁
    • 如果方法没有执行完之前释放了锁如调用了wait()方法，则程序再次进入等待集进行抢锁
  • Wait Set 等待集
    • 如果上方入口集，不同点是等待集在执行方法锁时中途释放了锁

wait、notify 实现生产者消费者模式

import java.util.LinkedList;
import java.util.List;
import java.util.TreeMap;

public class ProductAndConsumer {

    List<Object> container = new LinkedList<>();

    public static void main(String[] args) {
        ProductAndConsumer productAndConsumer = new ProductAndConsumer();
        Thread thread1 = new Thread(new Product(productAndConsumer));
        Thread thread2 = new Thread(new Consumer(productAndConsumer));
        thread1.start();
        thread2.start();
    }


    public synchronized void addObject() throws InterruptedException {
        if (container.size() >=100){
            wait();
        }
        container.add(new Object());
        System.out.println("正在生产第"+ container.size() + "个");
        notify();
    }

    public synchronized void conObject() throws InterruptedException {
        if (container.size() == 0){
            wait();
        }
        container.remove(0);
        System.out.println("正在消费第"+ container.size() + "个");
        notify();
    }
}

class Product implements Runnable{
    private final ProductAndConsumer productAndConsumer;

    Product(ProductAndConsumer productAndConsumer){
        this.productAndConsumer = productAndConsumer;
    }

    @Override
    public void run() {
       while (true){
           try {
               productAndConsumer.addObject();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

class Consumer implements Runnable{
    private final ProductAndConsumer productAndConsumer;

    Consumer(ProductAndConsumer productAndConsumer){
        this.productAndConsumer = productAndConsumer;
    }

    @Override
    public void run() {
       while (true){
           try {
               productAndConsumer.conObject();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}
解释
  • 使用类ProductAndConsumer作为锁对象，container作为容器
  • wait notify来进行线程之间的通讯，在数量满足条件时使用wait释放当前锁对象，另一个对象拿到锁之后进行生产或消费
图示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I5eDd3zx-1684475551604)(null)]

sleep()

Thread.sleep()是Java中一个静态native方法，用于使当前线程进入休眠状态（暂停执行）一段指定的时间。

它的方法签名为：

public static native void sleep(long millis) throws InterruptedException;

参数millis表示线程休眠的时间，以毫秒为单位。传入的值是一个正整数，表示线程要休眠的毫秒数。注意，该方法会抛出InterruptedException异常，因为线程在休眠期间可能被其他线程中断。

特点和用法
  • 线程阻塞：调用Thread.sleep()方法会导致当前线程暂停执行，进入阻塞状态。在指定的时间内，线程不会进行任何操作。
  • 时间精度：传入的休眠时间是以毫秒为单位，但实际的休眠时间可能会稍长或稍短。具体的精度取决于底层操作系统和JVM的实现。
  • 中断响应：如果在线程休眠期间，另一个线程中断了正在休眠的线程，Thread.sleep()方法会抛出InterruptedException异常。可以在catch块中处理该异常，或者将异常继续向上抛出。
  • 不会释放锁：Thread.sleep()方法会暂停当前线程的执行，但不会释放任何锁。如果线程在执行同步代码块或同步方法时调用了Thread.sleep()，其他线程仍无法获得该锁。
  • 静态方法：Thread.sleep()是一个静态方法，可以直接通过Thread类调用，无需创建线程对象。
  • 用途：常见的用途包括模拟延迟、定时任务、控制线程执行顺序等。
Thread.sleep和TimeUnit比较
  • 精度和可读性： Thread.sleep()的参数是以毫秒为单位的时间值，表示线程要休眠的时间。而TimeUnit提供了更高层次的时间单位，如TimeUnit.SECONDS表示秒，TimeUnit.MILLISECONDS表示毫秒等。使用TimeUnit可以使代码更具可读性，而不需要手动计算毫秒数。
  • 异常处理： Thread.sleep()方法会抛出InterruptedException异常，因为线程在休眠期间可能会被其他线程中断。而TimeUnit方式不会直接抛出异常，需要开发者手动处理中断情况。
  • 静态与非静态： Thread.sleep()是Thread类的静态方法，可以直接通过类名调用。而TimeUnit是一个枚举类，需要通过具体的枚举常量来调用其方法，例如TimeUnit.SECONDS.sleep(1)。
  • 可读性和易用性： 使用TimeUnit可以提高代码的可读性，因为可以直观地表示时间单位。此外，TimeUnit还提供了其他方法，如TimeUnit.toMillis()、TimeUnit.toSeconds()等，方便进行时间单位之间的转换。
TimeUnit源码

以下是截取部分源码

public enum TimeUnit {
      /**
     * Performs a {@link Thread#sleep(long, int) Thread.sleep} using
     * this time unit.
     * This is a convenience method that converts time arguments into the
     * form required by the {@code Thread.sleep} method.
     *
     * @param timeout the minimum time to sleep. If less than
     * or equal to zero, do not sleep at all.
     * @throws InterruptedException if interrupted while sleeping
     */
    public void sleep(long timeout) throws InterruptedException {
        if (timeout > 0) {
            long ms = toMillis(timeout);
            int ns = excessNanos(timeout, ms);
            Thread.sleep(ms, ns);
        }
    }
}

可以看到TimeUnit底层还是调用了Thread.sleep() 有一个比较隐含的地方就是当使用过TimeUnit的sleep方法时，如果传入的时间小于是不会进入if判断，而Thread.sleep()方法如果传参小于0则会抛出异常(源码见下)

public static void sleep(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }

    sleep(millis);
}

join()

Thread.join()是Java中的一个方法，用于等待调用该方法的线程执行完毕。它的作用是让当前线程等待指定线程执行结束，然后再继续执行当前线程的后续代码。

简单来说就是阻塞主线程。

简单示例
package ThreadMethod;

public class JoinMethod {
    public static void main(String[] args) {
        Thread thread1 =  new Thread(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完毕");
        },"子线程");
        thread1.start();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
    }
}
结果
子线程执行完毕
主线程执行完毕

可以看到子线程等待了3秒，但是最终还是子线程先执行完毕在执行主线程打印，原因是因为thread1.join 对主线程进行了阻塞，这是主线程需要等子线程执行完毕才会执行后面的语句

特点和注意事项
  • 等待执行： 调用join()方法的线程将会等待指定线程执行完毕。如果指定线程已经执行完毕，则join()方法会立即返回。
  • 阻塞调用线程： 在调用join()方法期间，当前线程将会被阻塞，暂停执行。只有当指定线程执行完毕后，当前线程才会解除阻塞，继续执行。
  • 异常处理： join()方法会抛出InterruptedException异常，因为在等待过程中，当前线程可能会被中断。可以在catch块中处理该异常，或将异常继续向上抛出。
  • 顺序执行： 通过使用join()方法，可以控制线程的执行顺序。调用join()方法后，当前线程会等待指定线程执行完毕，然后再继续执行后续代码。
  • 调用对象： join()方法是一个实例方法，需要通过线程对象调用。例如，如果thread1是一个Thread对象，可以使用thread1.join()来等待thread1执行完毕。
源码和底层实现

以下截取部分Thread.join源码

// 入口
public final void join() throws InterruptedException {
    join(0);
}

// 调用的join(0)
public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

// 实际调用的本地native方法  wait
public final native void wait(long timeout) throws InterruptedException;

可以看到join的底层还是使用wait方法实现的，子线程调用wait方法让主线程进入等待状态，在运行结束后自动调用notify方法唤醒主线程。（具体唤醒的方法在jvm中）

有一点疑问我没有找到解释：为什么调用子线程的wait(0)方法，阻塞的确是主线程呢？

CountDownLatch和CyclicBarrier

使用countDownLatch和CyclicBarrier也可以实现线程之间的阻塞，具体暂不讨论

yeild() (让步)

yield() 是一个静态方法，它属于 Thread 类，用于提示调度器将当前线程让出 CPU 的执行权，使得其他具有相同优先级的线程有机会执行。

yield() 方法的调用并不能保证一定会使其他线程获得执行机会，它仅是一个提示。具体的调度行为取决于操作系统和 JVM 的实现。因此，在实际应用中，不应过度依赖 yield() 方法来控制线程的执行顺序，而应使用更可靠的线程同步机制来实现需要的线程协作和同步。

nerkeler
关注
JAVA中的this关键字
aizha2535的博客
04-16 120
当成员变量和局部变量重名的时候，可以用this关键字来区分。 this：代表对象，代表哪个对象？------代表当前对象 　　　this就是所在函数所属对象的引用。(通俗说，哪个对象调用了this所在的函数，this就代表哪个对象) 举例：(下面的例子中是p1对象调用了this所在的函数compare，故this代表的对象就是p1) 1 public boolean com...
Servlet生命周期和常用方法
HYJ940228的博客
10-25 675
图解 详解： 浏览器发送HTTP请求到服务器——》服务器解析请求（分析具体访问哪一个servlet）——》创建Servlet实例并调用init方法进行初始化——》调用service方法——》将结果返回给服务器——》服务器返回给浏览器结果——》当服务器关闭或者应用被卸载调用destroy方法销毁servlet对象释放内存 如何解决Servlet线程安全问题 xml配置 ...
线程的生命周期与常用方法
YEN_CSDN的博客
06-15 1220
线程的生命周期一共五个状态：新建、就绪、运行、堵塞、死亡 （1）新建 new Thread Thread thread=new Thread(）； 当创建一个Thread对象时，这个线程就进入了新建状态，有了自己的内存空间，但还没有启动，此时线程还不是活的。 （2）就绪 runable 线程已经启动，正在等待CPU时间片。（通过线程的start()方法启动线程后进入就绪状态），此时具备运
线程的生命周期和状态控制
Du_XiaoNan的博客
06-21 1047
线程的生命周期，就是一个线程从创建到消亡的过程。关于Java中线程的生命周期，首先看一下下面这张较为经典的图：当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种不同的状态。尤其是当线程启动以后，它不可能一直“霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。
Java线程生命周期及常用方法说明
u011441473的专栏
06-13 1395
一、Java线程的生命周期——6大状态 Java线程从创建到销毁，一共经历6个状态（不一定每一种状态都经历）： NEW：初始状态，线程被构建，但是还没有调用start方法RUNNABLED：运行状态，JAVA线程把操作系统中的就绪和运行两种状态统一称为“运行中”BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了CPU使用权，阻塞也分为几种情况WAITING：等待状态TIME_WAITING：超时等待状态，超时以后自动返回TERMINATED：终止状态，表示当前线程执行完毕 J
Java Thread类的常用方法和生命周期
qq_35899077的博客
06-04 977
Java Thread类的常见方法和生命周期
Java线程生命周期以及方法详解
蒙的博客
06-24 3630
前言：现在的操作系统在运行一个程序时， 会为其创建一个进程。 在进程中操作系统调度的最小单元是线程， 也叫轻量级进程（Light Weight Process） ， 在一个进程里可以创建多个线程， 这些线程都拥有各自的计数器、 堆栈和局部变量等属性， 并且能够访问共享的内存变量。 处理器在这些线程上高速切换， 让使用者感觉到这些线程在同时执行。 啰嗦一下进程、线程是什么？ 进程是指一个内存中...
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
Java零基础之多线程篇：线程生命周期
喵手的博客
06-20 1074
在并发编程中，多线程是一种非常重要的技术手段，理论知识及线程创建我已经在上一章节讲过了，本章我们就不再赘述。我们都知道Java作为一种广泛应用的开发语言，提供了丰富的多线程编程支持。了解并掌握Java多线程的生命周期对于编写高效且可靠的多线程程序至关重要。所以在本文中，我将介绍Java多线程的生命周期，包括线程状态的转换和对应的方法调用，作为新一期的内容进行讲解，这也是为了帮助大家学习上能够循序渐进。
JAVA基础：线程生命周期、中断线程的方法
weixin_53755148的博客
10-07 1179
在同步方法或同步代码段中，获得的是哪个对象的对象锁，才可以调用哪个对象的wait方法。插队，当前线程调用指定线程对象的join方法，将指定线程加入当前线程的执行序列。指定睡眠时间，时间过后，自动唤醒，唤醒后，线程进入就绪状态，准备争抢CPU。一个称为条件队列，当一个线程已经获得了对象锁，因为某些业务条件不支持，当线程1234按顺序争抢锁时，线程1获得锁， 线程234进入同步队列。一般多因为逻辑数据未达标，需要临时让出对象锁，让其他线程先执行。表示让出当前对象的对象锁，获得当前对象锁的当前线程处于等待状态。
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
`ExecutorService`允许创建线程池，提交任务，并管理线程的生命周期，有效控制并发量，提高系统资源利用率。 5. **线程通信** - `BlockingQueue`: 阻塞队列是一种特殊的队列，当队列为空时，取元素的线程会被阻塞...
Java多线程总结（2） — 线程生命周期中常用方法
SunnyMarkLiu
12-14 1088
1. 线程的状态回顾  线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：（原文更好理解，就不翻译了） New When we create a new Thread object using new operator, thread state is New Thread. At this point, thread is not alive and it’s a sta
多线程—第三篇（Thread常用方法、线程生命周期）
qq_38906789的博客
05-22 240
Thread常用方法、线程生命周期1、Thread类中的常用的方法：2、线程的优先级：3、线程通信：4、线程的生命周期4.1 线程状态图4.2 线程5种状态说明： 1、Thread类中的常用的方法： start()：启动当前线程，调用当前线程的run() run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 currentThread()：静态方法，返回执行当前代码的线程 getName()：获取当前线程的名字 setName()：设置当前线程的名字 yield()：释
Java 简介
最新发布
qq_37168427的博客
03-02 33
Java 是一种基于类的，旨在具有尽可能少的实现依赖关系。它旨在让应用程序开发人员**一次编写并随处运行 （WORA），**这意味着编译后的 Java 代码可以在支持 Java 的所有平台上运行，而无需重新编译。ava 广泛用于开发桌面、Web 和移动设备的应用程序。Java 以其简单性、健壮性和安全功能而闻名，使其成为企业级应用程序的热门选择。Java 应用程序可以被编译为在任何 Java 虚拟机上运行的字节码。Java 的语法类似于 C/C++。Java 编写、编译和调试变得容易。
eclasticsearch文档搜索
sanshizhang的博客
02-27 676
本部简要介绍eclasticsearch在文档所搜的应用。
Spring Boot 实战篇（四）：实现用户登录与注册功能
m0_74824823的博客
02-27 1526
在构建 Web 应用程序时，用户登录与注册功能是常见且重要的部分。以下将详细介绍在 Spring Boot 项目中实现用户登录与注册功能的步骤，并附上相应的代码示例。
（七）消息队列-Kafka 序列化avro（传递）
平凡君
02-27 941
多年前，由于工作的性质，发现这系列没有写完，想了想，做人做事还是要有始有终。🤣实在是借口太多了，太不像话了…由于时间过得太久了，这篇开始，可能很多技术以最新或最近的几个版本为主了。Avro通过Schema定义与二进制编码，为Kafka提供了高效、类型安全的序列化方案。结合Schema Registry可实现动态兼容性管理，适用于复杂业务场景下的数据演进需求。实践中需注意Schema版本控制与性能调优，具体工具链配置可参考Confluent官方文档27。
【GESP】C++二级真题 luogu-B4037 [GESP202409 二级] 小杨的 N 字矩阵
CoderCoding的博客
02-28 459
【GESP】C++二级真题 luogu-B4037 [GESP202409 二级] 小杨的 N 字矩阵 | OneCoder。GESP二级真题，多层循环和分支练习，难度★✮☆☆☆。GESP二级真题，多层循环和分支练习，难度★✮☆☆☆。
JVM内存模型详解：各个区域的作用与原理
秃头之旅
02-28 919
方法区（Method Area）堆（Heap）栈（Stack）本地方法栈（Native Method Stack）程序计数器（Program Counter Register）这些区域共同协作，确保Java程序的正常运行。下面我们将逐一介绍这些区域。JVM内存模型是Java程序运行的基础，理解各个内存区域的作用和原理对于编写高效、稳定的Java程序至关重要。方法区：存储类信息、常量、静态变量等。堆：存储对象实例和数组，是垃圾回收的主要区域。栈：存储局部变量和方法调用，线程私有。本地方法栈。
Java线程生命周期及其关键方法详解
Java线程生命周期的理解和管理是Java编程的重要组成部分，熟练掌握这些方法和概念有助于编写高效、健壮的多线程程序。在实际开发中，应注意避免使用已废弃的方法，并充分考虑线程安全性和性能优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值