• Tags
  •         
  • www.breakyizhan.com
  •    

    任何时间点的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