详解Java线程的几种状态

简介: 详解Java线程的几种状态

一言不合翻源码,一下就是Thread类源码中State内置枚举,列举出了Java线程的几种状态:

/**
 * A thread state.  A thread can be in one of the following states:
 * <ul>
 * <li>{@link #NEW}<br>
 *     A thread that has not yet started is in this state.
 *     </li>
 * <li>{@link #RUNNABLE}<br>
 *     A thread executing in the Java virtual machine is in this state.
 *     </li>
 * <li>{@link #BLOCKED}<br>
 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
 *     </li>
 * <li>{@link #WAITING}<br>
 *     A thread that is waiting indefinitely for another thread to
 *     perform a particular action is in this state.
 *     </li>
 * <li>{@link #TIMED_WAITING}<br>
 *     A thread that is waiting for another thread to perform an action
 *     for up to a specified waiting time is in this state.
 *     </li>
 * <li>{@link #TERMINATED}<br>
 *     A thread that has exited is in this state.
 *     </li>
 * </ul>
 *
 * <p>
 * A thread can be in only one state at a given point in time.
 * These states are virtual machine states which do not reflect
 * any operating system thread states.
 *
 * @since   1.5
 * @see #getState
 */
public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,
    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,
    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,
    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,
    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,
    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}
复制代码


1 什么是线程[来源:百度百科]

     线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程(lightweight processes),但轻量进程更多指内核线程(kernel thread),而把用户线程(user thread)称为线程。

      线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程,如Win32线程;由用户进程自行调度的用户线程,如Linux平台的POSIX Thread;或者由内核与用户进程,如Windows 7的线程,进行混合调度。

      同一进程中的多条线程将共享该进程中的全部系统资源,如虚拟地址空间,文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack),自己的寄存器环境(register context),自己的线程本地存储(thread-local storage)。

      一个进程可以有很多线程,每条线程并行执行不同的任务。

      在多核或多CPU,或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见,即提高了程序的执行吞吐率。在单CPU单核的计算机上,使用多线程技术,也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行,编写专门的workhorse线程执行密集计算,从而提高了程序的执行效率。

2 Thread的几种状态

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

NEW(新线程态)、RUNNABLE(可运行态)、 BLOCKED(阻塞态)、WAITING(等待状态)、TIMED_WAITING(定时等待状态)、TERMINATED(终止状态)

3 分别介绍

3.1 NEW

尚未启动的线程的线程状态。

产生一个Thread对象就生成一个新线程。当线程处于"新线程"状态时,仅仅是一个空线程对象,它还没有分配到系统资源。因此只能启动或终止它。任何其他操作都会引发异常。例如,一个线程调用了new方法之后,并在调用start方法之前的处于新线程状态,可以调用start和stop方法。

触发方式:

Thread thread = new Thread();
复制代码


3.2 RUNNABLE

可运行线程的线程状态。 一个处于可运行状态的线程正在Java虚拟机中执行,但它可能正在等待来自操作系统(如处理器)的其他资源。

start()方法产生运行线程所必须的资源,调度线程执行,并且调用线程的run()方法。在这时线程处于可运行态。该状态不称为运行态是因为这时的线程并不总是一直占用处理机。特别是对于只有一个处理机的PC而言,任何时刻只能有一个处于可运行态的线程占用处理 机。Java通过调度来实现多线程对处理机的共享。注意,如果线程处于Runnable状态,它也有可能不在运行,这是因为还有优先级和调度问题。

触发方式

Thread thread = new Thread();
thread.start();
thread.run();
复制代码

start()和run()方法有什么不同?

再次翻源码:

/**
 * Causes this thread to begin execution; the Java Virtual Machine
 * calls the <code>run</code> method of this thread.
 * <p>
 * 翻译:使此线程开始执行;Java虚拟机调用该线程的run方法。
 * The result is that two threads are running concurrently: the
 * current thread (which returns from the call to the
 * <code>start</code> method) and the other thread (which executes its
 * <code>run</code> method).
 * 翻译:结果是两个线程同时运行:当前线程(从调用start方法返回)和另一个线程(执行其run方法)。
 * <p>
 * It is never legal to start a thread more than once.
 * In particular, a thread may not be restarted once it has completed
 * execution.
 * 翻译:线程启动一次以上是不合法的。 特别是,线程在完成执行后可能不会重新启动。
 */
public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    /* 通知该组该线程即将启动,以便将其添加到该组的线程列表中,并且该组的未启动计数可以减少。 */
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
/**
 * If this thread was constructed using a separate
 * <code>Runnable</code> run object, then that
 * <code>Runnable</code> object's <code>run</code> method is called;
 * otherwise, this method does nothing and returns.
 * 翻译:如果这个线程是使用一个单独的Runnable 对象构造的,那么Runnable对象的run方法被调用;否则,此方法不执 
 * 行任何操作并返回。
 * <p>
 * Subclasses of <code>Thread</code> should override this method.
 * 翻译:Thread的子类应该覆盖这个方法。  
 */
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}
复制代码

由源码我们可以知道:

  • 调用start()方法时,先放入线程组,进行异步执行,而不一定是直接进行执行
  • 调用run()方法,进行同步执行,即直接执行

3.3 BLOCKED

等待监视器锁而阻塞的线程的线程状态。 处于阻塞状态的线程正在等待监视器锁进入一个同步的块/方法,或者在调用Object.wait之后重新进入一个同步的块/方法。

触发机制

Object.wait();
thread.interrupt()
复制代码

3.4 WAITING

一个处于等待状态的线程正在等待另一个线程执行一个特定的动作。

触发机制

Object.wait();
thread.join()
或(锁支持)
LockSupport.park()
复制代码

取消等待:

Object.notify() 
Object.notifyAll()
复制代码

3.5 TIMED_WAITING

具有指定等待时间的等待线程的线程状态。由于调用了下列方法中的一个,并且指定了正等待时间,线程处于定时等待状态

触发机制

Thread.sleep()
Object.wait()
Thread.join()
LockSupport.parkNanos
LockSupport.parkUntil
复制代码

3.6 TERMINATED

终止线程的线程状态。 线程已经完成执行。

触发机制

thread.stop();


相关文章
|
1天前
|
并行计算 Java 大数据
Java中的高效并行计算与多线程编程技术
Java中的高效并行计算与多线程编程技术
|
1天前
|
算法 安全 Java
Java小白教学—五千字带你了解多线程机制及线程安全问题
Java小白教学—五千字带你了解多线程机制及线程安全问题
|
1天前
|
安全 Java
解决Java中多线程同步问题的方案
解决Java中多线程同步问题的方案
|
1天前
|
安全 Java 开发者
Java多线程编程实践中的常见问题与解决方案
Java多线程编程实践中的常见问题与解决方案
|
1天前
|
安全 Java
Java多线程编程实践中的常见问题与解决方案
Java多线程编程实践中的常见问题与解决方案
|
1天前
|
设计模式 Java 容器
Java多线程编程中的设计模式与挑战
Java多线程编程中的设计模式与挑战
|
2天前
|
Java 数据处理 调度
Java多线程编程入门指南
Java多线程编程入门指南
|
3天前
|
安全 Java 开发者
Java并发编程中的线程安全策略
在现代软件开发中,Java语言的并发编程特性使得多线程应用成为可能。然而,随着线程数量的增加,如何确保数据的一致性和系统的稳定性成为开发者面临的挑战。本文将探讨Java并发编程中实现线程安全的几种策略,包括同步机制、volatile关键字的使用、以及java.util.concurrent包提供的工具类,旨在为Java开发者提供一系列实用的方法来应对并发问题。
9 0
|
3天前
|
监控 Java UED
Java并发编程:深入理解线程池的设计与应用
本文旨在通过数据导向和科学严谨的方式,深入探讨Java并发编程中的关键组件——线程池。文章首先概述了线程池的基本概念与重要性,随后详细解读了线程池的核心参数及其对性能的影响,并通过实验数据支持分析结果。此外,文中还将介绍如何根据不同的应用场景选择或设计合适的线程池,以及如何避免常见的并发问题。最后,通过案例研究,展示线程池在实际应用中的优化效果,为开发人员提供实践指导。
9 0
|
3天前
|
监控 安全 算法
如何有效地处理Java中的多线程
如何有效地处理Java中的多线程