任何时间点的Java中的线程都存在于以下任何一种状态中。线程在任何时刻仅处于所示状态之一:

  1. New
  2. Runnable
  3. Blocked
  4. Waiting
  5. Timed Waiting
  6. Terminated

下图显示了任何时刻线程的各种状态。

Java中, 线程的生命周期和状态

线程的生命周期

  1. 新线程:创建新线程时,它处于新状态。当线程处于此状态时,线程尚未开始运行。当一个线程处于新状态时,它的代码尚未运行且尚未开始执行。
  2. 可运行状态准备运行的线程被移动到可运行状态。在这种状态下,线程可能实际上正在运行,或者它可能在任何时刻都准备好运行。线程调度程序负责为线程提供运行时间。
    多线程程序为每个单独的线程分配固定的时间量。每个线程都会运行一段时间,然后暂停并放弃CPU到另一个线程,这样其他线程就有机会运行。发生这种情况时,所有准备运行的等待CPU和当前运行的线程的线程都处于runnable状态。
  3. 阻止/等待状态:当线程暂时处于非活动状态时,它处于以下状态之一:
    • 阻止
    • 等候

    例如,当线程正在等待I / O完成时,它处于阻塞状态。线程调度程序负责重新激活和计划阻塞/等待线程。处于此状态的线程无法继续执行,直到它被移动到可运行状态。这些状态中的任何线程都不消耗任何CPU周期。

    当一个线程试图访问当前被某个其他线程锁定的受保护代码段时,它处于阻塞状态。当受保护的部分被解锁时,该计划选择被阻止该部分的一个线程并将其移动到可运行状态。然而,当线程在某个条件上等待另一个线程时,它处于等待状态。满足此条件时,将通知调度程序并将等待线程移至可运行状态。

    如果当前正在运行的线程被移动到阻塞/等待状态,则线程调度程序将调度处于可运行状态的另一个线程以运行。线程调度程序负责确定要运行的线程。

  4. 定时等待:线程在调用具有超时参数的方法时处于定时等待状态。线程处于此状态,直到超时完成或收到通知为止。例如,当线程调用sleep或条件等待时,它将被移动到定时等待状态。
  5. 终止状态:由于以下原因之一,线程终止:
    • 因为它存在正常。当线程代码完全由程序执行时会发生这种情况。
    • 因为发生了一些不寻常的错误事件,如分段错误或未处理的异常。

    处于已终止状态的线程不再消耗任何CPU周期。

用Java实现线程状态

在Java中,要获取线程的当前状态,请使用Thread.getState()方法获取线程的当前状态。Java提供了java.lang.Thread.State类,它定义了线程状态的ENUM常量,如下所示:

  1. 常数型:NEW
    声明:public static final Thread.State NEW

    描述:尚未启动的线程的线程状态。

  2. 常量类型: Runnable
    声明:public static final Thread.State RUNNABLE

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

  3. 常数类型:BLOCKED
    声明:public static final Thread.State BLOCKED

    描述:线程阻塞等待监视器锁定的线程状态。处于阻塞状态的线程正在等待监视器锁定以在调用Object.wait()之后输入同步块/方法或重新输入同步块/方法。

  4. 常数类型:WAITING
    声明:public static final Thread.State WAITING

    描述:等待线程的线程状态。等待线程的线程状态。由于调用以下方法之一,线程处于等待状态:

    • Object.wait with no timeout
    • Thread.join with no timeout
    • LockSupport.park

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

  5. 常量类型:Time waiting
    声明:public static final Thread.State TIMED_WAITING

    描述:具有指定等待时间的等待线程的线程状态。由于在指定的正等待时间内调用以下方法之一,线程处于定时等待状态:

    • Thread.sleep
    • Object.wait with timeout
    • Thread.join with timeout
    • LockSupport.parkNanos
    • LockSupport.parkUntil
  6. 常数类型:Terminated
    声明:public static final Thread.State TERMINATED

    描述:已终止线程的线程状态。线程已完成执行。

// Java program to demonstrate thread states
class thread implements Runnable
{
    public void run()
    {
        // moving thread2 to timed waiting state
        try
        {
            Thread.sleep(1500);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        try
        {
            Thread.sleep(1500);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("State of thread1 while it called join() method on thread2 -"+
            Test.thread1.getState());
        try
        {
            Thread.sleep(200);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }    
    }
}
public class Test implements Runnable
{
    public static Thread thread1;
    public static Test obj;
    
    public static void main(String[] args)
    {
        obj = new Test();
        thread1 = new Thread(obj);
        
        // thread1 created and is currently in the NEW state.
        System.out.println("State of thread1 after creating it - " + thread1.getState());
        thread1.start();
        
        // thread1 moved to Runnable state
        System.out.println("State of thread1 after calling .start() method on it - " +
            thread1.getState());
    }
    
    public void run()
    {
        thread myThread = new thread();
        Thread thread2 = new Thread(myThread);
        
        // thread1 created and is currently in the NEW state.
        System.out.println("State of thread2 after creating it - "+ thread2.getState());
        thread2.start();
        
        // thread2 moved to Runnable state
        System.out.println("State of thread2 after calling .start() method on it - " +
            thread2.getState());
        
        // moving thread1 to timed waiting state
        try
        {
            //moving thread2 to timed waiting state
            Thread.sleep(200);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("State of thread2 after calling .sleep() method on it - "+
            thread2.getState() );
        
        
        try
        {
            // waiting for thread2 to die
            thread2.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("State of thread2 when it has finished it's execution - " +
            thread2.getState());
    }
    
}

输出:

State of thread1 after creating it - NEW
State of thread1 after calling .start() method on it - RUNNABLE
State of thread2 after creating it - NEW
State of thread2 after calling .start() method on it - RUNNABLE
State of thread2 after calling .sleep() method on it - TIMED_WAITING
State of thread1 while it called join() method on thread2 -WAITING
State of thread2 when it has finished it's execution - TERMINATED

说明:创建新线程时,线程处于NEW状态。在线程上调用.start()方法时,线程调度程序将其移动到Runnable状态。每当在线程实例上调用join()方法时,执行该语句的当前线程将等待此线程移动到Terminated状态。因此,在控制台上打印最终语句之前,程序调用thread2上的join(),使thread1等待,而thread2完成其执行并移至Terminated状态。thread1进入等待状态,因为它等待thread2完成它的执行,因为它在thread2上调用了join。

 
转载请保留页面地址:https://www.breakyizhan.com/java/4933.html
扫描二维码添加微信 
  • ,每次淘宝领取淘宝优惠券,淘宝购物更优惠。现在添加微信,还可以领取机械键盘50元优惠券!添加微信后回复机械键盘即可领取!
    支持我们,就用微信淘宝!