为什么有些人说Java线程五种状态,有些人说六种?

2023年 11月 7日 120.7k 0

Java线程是Java并发编程的基础,理解Java线程的生命周期对于编写高效、稳定的并发程序至关重要。本文将从两个角度来介绍Java线程的生命周期,并通过代码示例进行验证。

一、复习

在Java中,线程的创建主要通过两种方式:继承Thread类或实现Runnable接口、Callnablee接口。以下是一个简单的示例:

1.1 创建线程的方式

1.1.1 创建建方式一:继承Thread类

步骤:

  • 创建自定义类继承于Thread类,并重写Thread类的run()方法。该run()方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
  • 创建自定义类(Thread子类)的实例,即创建了线程对象。
  • 调用线程对象的start()方法来启动该线程。
  • /**
     * Java中创建线程方式一:继承Thread类
     */
    public class ThreadTest extends Thread{
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
            }
        }
    
        public static void main(String[] args) {
            ThreadTest threadTest = new ThreadTest();
            threadTest.start();
        }
    }

    打印结果:

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

    1.1.2 创建方式二:实现Runnable接口

    步骤:

  • 创建自定义类实现于Runnable接口,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
  • 创建自定义类(Runnable实现类)的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
  • 调用线程对象的start()方法来启动该线程。
  • /**
     * Java中创建线程方式二:实现Runnable接口
     */
    public class RunnableTest implements Runnable{
    
        @Override
        public void run() {
            for (int i = 100; i < 110; i++) {
                System.out.println(i);
            }
        }
    
        public static void main(String[] args) {
            RunnableTest runnableTest = new RunnableTest();
            Thread thread = new Thread(runnableTest);
            thread.start();
        }
    }

    打印结果:

    100
    101
    102
    103
    104
    105
    106
    107
    108
    109

    1.1.3 创建方式三:通过Callable和Future创建线程

    Callable和Future出现的背景

    一般创建线程时,使用上面两种方式居多。但是这两种方式都有一个缺陷:在执行完任务之后无法获取执行结果。

    如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦。

    而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果。

    Callable和Future简介

    Callable接口可以理解成一段可以调用并返回结果的代码(call方法);

    Future接口表示异步任务,是还没有完成的任务给出的未来结果。

    所以说Callable用于产生结果,Future用于获取结果。这点可以在源码里面分析得知。

    源码分析

    先看Runnable源码

    Runnable位于java.lang包下,它是一个接口,在它里面声明了一个方法叫做 run():

    @FunctionalInterface
    public interface Runnable {
        public abstract void run();
    }

    由于run()方法返回值为void类型,所以在执行完任务之后无法返回任何结果。

    再看Callable源码Callable位于java.util.concurrent包下,它也是一个接口,在它里面也只声明了一个方法,只不过这个方法叫做call():

    @FunctionalInterface
    public interface Callable {
        V call() throws Exception;
    }

    可以看到,这是一个泛型接口,call()函数返回的类型就是传递进来的V类型。

    Future源码

    Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。为什么这么说呢?看了它的源码就知道了。

    Future类位于java.util.concurrent包下,它也是一个接口

    package java.util.concurrent;
    
    public interface Future {
    
    	/**
         * 取消任务
         */
        boolean cancel(boolean mayInterruptIfRunning);
    
    	/**
         * 任务是否被取消成功
         */
        boolean isCancelled();
    
    	/**
         * 任务是否已经完成
         */
        boolean isDone();
    	
    	/**
         * 获取执行结果
         */
        V get() throws InterruptedException, ExecutionException;
    
    	/**
         * 获取执行结果,支持超时
         */
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }

    所以说Future一共给我们提供了三种功能:

    • 能够取消任务。
    • 判断任务是否完成。
    • 能够获取任务执行结果。

    但是因为Future只是一个接口,所以是无法直接用来创建对象使用的,因此就有了下面的FutureTask。

    FutureTask实现于RunnableFuture接口,这个接口的定义如下:

    public interface RunnableFuture extends Runnable, Future {
        void run();
    }

    可以看到这个接口实现了Runnable和Future接口,接口中的具体实现由FutureTask来实现。这个类的两个构造方法如下 :

    public FutureTask(Callable callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
    
    	public FutureTask(Runnable runnable, V result) {
            this.callable = Executors.callable(runnable, result);
            this.state = NEW;       // ensure visibility of callable
        }

    如上提供了两个构造函数,一个以Callable为参数,另外一个以Runnable为参数。这些类之间的关联允许你基于FutureTask的Runnable特性(因为它实现了Runnable接口),把任务写成Callable,然后封装进一个由执行者调度并在必要时可以取消的FutureTask。

    FutureTask可以由执行者调度,它对外提供的方法基本上就是Future和Runnable接口的组合:get()、cancel、isDone()、isCancelled()和run(),而run()方法通常都是由执行者调用,我们基本上不需要直接调用它。

    通过Callable和Future创建一个线程

    步骤:

  • 创建自定义类实现于Callable接口,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
  • 创建自定义类(Callable实现类)的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
  • 使用FutureTask对象作为Thread对象的target创建并启动新线程。
  • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
  • 示例:

    /**
     * Java中创建线程方式三:Callable和FutureTask结合使用
     */
    public class CallableTest implements Callable{
    
        @Override
        public Object call() throws Exception {
            int i = 1000;
            for ( ; i < 1010; i++) {
                System.out.println(i);
            }
            return 1111;
        }
    
        public static void main(String[] args) {
            CallableTest callableTest = new CallableTest();
            FutureTask futureTask = new FutureTask(callableTest);
            Thread thread = new Thread(futureTask);
            thread.start();
    
            try {
                System.out.println("Result:"+futureTask.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
    
        }
    }

    打印结果:

    1000
    1001
    1002
    1003
    1004
    1005
    1006
    1007
    1008
    1009
    Result:1111

    1.2 面试题:Runable接口和Calla

    返回值:

    • Runnable接口的run()方法没有返回值,它表示一个没有返回结果的任务。
    • Callable接口的call()方法有返回值,可以返回计算结果。

    异常处理:

    • Runnable接口的run()方法不能抛出受检查异常,只能通过捕获异常并在方法内部处理。
    • Callable接口的call()方法可以抛出受检查异常,调用者需要捕获并处理异常。

    使用方式

    • Runnable接口通常用于执行没有返回结果的任务,可以通过Thread类的构造函数来创建线程并传递一个Runnable对象。
    • Callable接口通常用于执行有返回结果的任务,需要配合ExecutorService接口或Future接口来提交和执行任务。

    返回结果获取

    • Runnable接口没有提供直接获取任务执行结果的方法。
    • Callable接口的call()方法返回一个Future对象,通过该对象可以获取任务的执行结果。ble接口的区别

    二、线程池的生命周期

    Java线程的状态可以被划分为五种或六种,这主要取决于你从哪个角度来看。在操作系统的传统线程模型中,线程通常被分为五种状态。

    2.1 从JVM源代码看线程周期:

  • 初始 (NEW) :新创建了一个线程对象,但还没有调用start ()方法3。
  • 运行 (RUNNABLE) :Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
  • 阻塞 (BLOCKED) :表示线程阻塞于锁3。
  • 等待 (WAITING) :进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
  • 超时等待 (TIMED_WAITING) :该状态不同于WAITING,它可以在指定的时间后自行返回
  • 终止 (TERMINATED) :表示该线程已经执行完毕
  • 2.2 从操作系统的层面来看:

  • 新建状态 (New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread ()2。
  • 就绪状态 (Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start ()方法,从而来启动该线程。例如,thread.start ()。处于就绪状态的线程,随时可能被CPU调度执行2。
  • 运行状态 (Running): 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态2。
  • 阻塞状态 (Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:等待阻塞、同步阻塞和其他阻塞2。
  • 死亡状态 (Dead): 线程执行完了或者因异常退出了run ()方法,该线程结束生命周期2。
  • 总结

    操作系统层面的五种线程状态和JVM的六种线程状态是两个不同层次的概念,它们之间并不是一一对应的关系。

    JVM并不关心操作系统线程的实际状态,从JVM看来,等待CPU使用权(操作系统状态为可运行态)与等待I/O(操作系统处于等待状态)没有区别,都是在等待某种资源,所以都归入RUNNABLE状态。因此,操作系统层面的线程状态并不直接影响JVM的线程状态。

    这两者的主要区别在于它们关注的焦点不同:操作系统更关注线程对CPU和I/O资源的使用,而JVM更关注线程在Java程序中的行为。

    在「JDK1.2之后」,Java线程模型已经确定了基于操作系统原生线程模型实现。因此,目前或者今后的JDK版本中,操作系统支持怎么样的线程模型,在很大程度上决定了Java虚拟机的线程如何映射,这一点在不同的平台上没有办法达成一致,虚拟机规范中也未限定Java线程需要使用哪种线程模型来实现。线程模型只对线程的并发规模和操作成本产生影响,对于Java程序来说,这些差异是透明的。

    对应Oracle Sun JDK或者说Oracle Sun JVM而言,它的Windows版本和Linux版本都是使用「一对一的线程模型」实现的。

    一对一的线程模型也就是一条Java线程就映射到一条轻量级进程(「Light Weight Process」)中,而一条轻量级线程又映射到一条内核线程(「Kernel-Level Thread」)。我们平时所说的线程,往往就是指轻量级进程(或者通俗来说我们平时新建的java.lang.Thread就是轻量级进程实例的一个"句柄",因为一个java.lang.Thread实例会对应JVM里面的一个JavaThread实例,而JVM里面的JavaThread就应该理解为轻量级进程)。推算这个线程映射关系,可以知道,我们在应用程序中创建或者操作的java.lang.Thread实例最终会映射到系统的内核线程,如果我们恶意或者实验性无限创建java.lang.Thread实例,最终会影响系统的正常运行甚至导致系统崩溃(可以在Windows开发环境中做实验,确保内存足够的情况下使用死循环创建和运行java.lang.Thread实例)。

    相关文章

    JavaScript2024新功能:Object.groupBy、正则表达式v标志
    PHP trim 函数对多字节字符的使用和限制
    新函数 json_validate() 、randomizer 类扩展…20 个PHP 8.3 新特性全面解析
    使用HTMX为WordPress增效:如何在不使用复杂框架的情况下增强平台功能
    为React 19做准备:WordPress 6.6用户指南
    如何删除WordPress中的所有评论

    发布评论