Компьютерный справочник
1 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд

Java thread states

Java Thread Life Cycle and Thread States

By Lokesh Gupta | Filed Under: Java Concurrency

A java thread can be in any of following thread states during it’s life cycle i.e. New, Runnable, Blocked, Waiting, Timed Waiting or Terminated. These are also called life cycle events of a thread in java. Let’s understand each state in more detail.

Java Thread Life Cycle States

As soon as, you create new thread, it’s in NEW state. It remains in this state until the program starts the thread using it’s start() method.

At this point, thread is not alive and it’s a state internal to Java programming.


Calling start() method on thread put it in RUNNABLE state. At this point, execution control is passed to thread scheduler to finish it’s execution. Thread scheduler decide from this point that this thread should be executed (also known as dispatching the thread) or should be put on hold to give chance to other runnable threads.

In most operating systems, each thread is given a small amount of processor time—called a quantum or timeslice—with which to perform its task. A task utilizing it’s quantum is said to be in RUNNING state. When its quantum expires, the thread returns to the RUNNABLE state, and the operating system assigns another thread to the processor.

The process that an operating system uses to determine which thread to dispatch is called thread scheduling and is dependent on thread priorities.


A RUNNABLE thread transitions to the BLOCKED state when it attempts to perform a task that cannot be completed immediately and it must temporarily wait until that task completes.

For example, when a thread issues an input/output request, the operating system blocks the thread from executing until that I/O request completes—at that point, the blocked thread transitions to the RUNNABLE state, so it can resume execution. A blocked thread cannot use a processor, even if one is available.


A thread can be put in waiting state for various reasons e.g. calling it’s wait() method. Usually program put a thread in WAIT state because something else needs to be done prior to what current thread is doing.

Once the thread wait state is over or it is, it’s state is changed to RUNNABLE and it’s moved back to thread pool.

Timed Waiting

A RUNNABLE thread can transition to the TIMED WAITING state if it provides an optional wait interval when it’s waiting for another thread to perform a task. You can put a java thread in TIMED WAITING state by calling it’s sleep(long millis) method or wait(long millis) method.

Such a thread returns to the RUNNABLE state when it’s notified by another thread or when the timed interval expires—whichever comes first.

Timed waiting threads and waiting threads cannot use a processor, even if one is available.


A thread enters the TERMINATED state (sometimes called the dead state) when it successfully completes its task or otherwise terminated due to any error or even it was forcefully killed.

Please remember that though JVM and OS thread scheduler do their best yet sometimes threads can cause starvation or deadlock. This occurs when a waiting thread (let’s call this thread1) cannot proceed because it’s waiting (either directly or indirectly) for another thread (let’s call this thread2) to proceed, while simultaneously thread2 cannot proceed because it’s waiting (either directly or indirectly) for thread1 to proceed.

Java 6 Thread States and Life Cycle

UML Protocol State Machine Diagram Example

This is an example of UML protocol state machine diagram showing thread states and thread life cycle for the Thread class in Java 6.

Thread is a lightweight process, the smallest unit of scheduled execution. Instance of the Thread class in Java 6 could be in one of the following states:

  • new,
  • runnable,
  • timed waiting,
  • waiting,
  • blocked,
  • terminated.

These states are Java Virtual Machine (JVM) states reported by JVM to Java programs. At any given point in time thread could be in only one state.

Protocol state machine example — Thread states and life cycle in Java 6

New is the thread state for a thread which was created but has not yet started.

At the lower operating system (OS) level, JVM’s runnable state could be considered as a composite state with two substates. When a thread transitions to the runnable JVM state, the thread first goes into the ready substate. Thread scheduling decides when the thread could actually start, proceed or be suspended. Thread.yield() is explicit recommendation to thread scheduler to pause the currently executing thread to allow some other thread to execute.

A thread in the runnable state is executing from the JVM point of view but in fact it may be waiting for some resources from the operating system.

Timed waiting is a thread state for a thread waiting 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:

  • Thread.sleep(sleeptime)
  • Object.wait(timeout)
  • Thread.join(timeout)
  • LockSupport.parkNanos(timeout)
  • LockSupport.parkUntil(timeout)
Читать еще:  Javascript round to 2 digits

A thread is in the waiting state due to the calling one of the following methods without timeout:

Note, that thread in the waiting state is waiting for another thread to perform a particular action. For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate. It means that waiting state could be made a composite state with states corresponding to these specific conditions.

Thread is in the blocked state while waiting for the monitor lock to enter a synchronized block or method or to reenter a synchronized block or method after calling Object.wait().

A synchronized statement or method acquires a mutual-exclusion lock on behalf of the executing thread, executes a block or method, and then releases the lock. While the executing thread owns the lock, no other thread may acquire the lock and is blocked waiting for the lock.

After thread has completed execution of run() method, it is moved into terminated state.

Noticed a spelling error? Select the text using the mouse and press Ctrl + Enter.

This document describes UML versions up to UML 2.5 and is based on the corresponding OMG™ Unified Modeling Language™ (OMG UML®) specifications. UML diagrams were created in Microsoft® Visio® 2007-2016 using UML 2.x Visio Stencils.

Жизненный цикл и состояния потока в Java

Поток в Java в любой момент времени существует в любом из следующих состояний. Поток лежит только в одном из показанных состояний в любой момент:

  1. новый
  2. Runnable
  3. блокированный
  4. Ожидание
  5. Время ожидания
  6. Отменено

Диаграмма, показанная ниже, представляет различные состояния потока в любой момент времени.

Источник изображения: Core Java, том 1, 9-е издание, Horstmann, Cay S. & Cornell, Gary_2013

Жизненный цикл потока

  1. Новый поток : когда создается новый поток, он находится в новом состоянии. Поток еще не начал работать, когда поток находится в этом состоянии. Когда поток находится в новом состоянии, его код еще не запущен и не начал выполняться.
  2. Состояние выполнения: поток, готовый к запуску, переводится в состояние выполнения. В этом состоянии поток на самом деле может быть запущен или готов к запуску в любой момент времени. Планировщик потока обязан дать потоку время для запуска.
    Многопоточная программа выделяет фиксированное количество времени для каждого отдельного потока. Каждый поток запускается на короткое время, а затем приостанавливает и передает ЦП другому потоку, так что другие потоки могут получить возможность работать. Когда это происходит, все такие потоки, которые готовы к запуску, ожидают ЦП и текущий запущенный поток, находятся в состоянии выполнения.
  3. Состояние блокировки / ожидания: если поток временно неактивен, он находится в одном из следующих состояний:
    • блокированный
    • Ожидание

Например, когда поток ожидает завершения ввода-вывода, он находится в заблокированном состоянии. Планировщик потока отвечает за повторную активацию и планирование заблокированного / ожидающего потока. Поток в этом состоянии не может продолжать выполнение до тех пор, пока не будет переведен в работоспособное состояние. Любой поток в этих состояниях не потребляет цикл ЦП.

Поток находится в заблокированном состоянии, когда он пытается получить доступ к защищенному разделу кода, который в данный момент заблокирован каким-либо другим потоком. Когда защищенный раздел разблокирован, расписание выбирает один из потоков, заблокированных для этого раздела, и переводит его в работоспособное состояние. Принимая во внимание, что поток находится в состоянии ожидания, когда он ожидает другого потока в условии. Когда это условие выполнено, планировщик уведомляется, и ожидающий поток переводится в работоспособное состояние.

Если текущий запущенный поток переводится в состояние блокировки / ожидания, планировщик потока планирует запустить другой поток в состоянии запуска. Ответственность за определение потока для выполнения лежит на планировщике потоков.

  • Ожидание по времени: поток находится в состоянии ожидания по времени, когда он вызывает метод с параметром времени ожидания. Поток находится в этом состоянии до истечения времени ожидания или до получения уведомления. Например, когда поток вызывает sleep или условное ожидание, он переводится в состояние ожидания по времени.
  • Завершенное состояние: поток завершается по одной из следующих причин:
    • Потому что это существует нормально. Это происходит, когда код потока полностью выполнен программой.
    • Потому что произошло какое-то необычное ошибочное событие, такое как ошибка сегментации или необработанное исключение.

    Поток, который находится в завершенном состоянии, больше не потребляет циклов ЦП.

    Реализация состояний потоков в Java

    В Java, чтобы получить текущее состояние потока, используйте метод Thread.getState (), чтобы получить текущее состояние потока. Java предоставляет класс java.lang.Thread.State, который определяет константы ENUM для состояния потока, сводка которых приведена ниже:

      Тип константы: Новый

    Описание: состояние потока для потока, который еще не начался.

    Тип константы: Runnable

    Описание: состояние потока для работающего потока. Поток в состоянии выполнения выполняется на виртуальной машине Java, но он может ожидать других ресурсов от операционной системы, таких как процессор.

    Тип константы: заблокирован

    Описание: состояние потока для потока, заблокированного в ожидании блокировки монитора. Поток в заблокированном состоянии ожидает блокировки монитора, чтобы войти в синхронизированный блок / метод или повторно войти в синхронизированный блок / метод после вызова Object.wait ().

    Тип константы: Ожидание

    Описание: состояние потока для ожидающего потока. Состояние потока для ожидающего потока. Поток находится в состоянии ожидания из-за вызова одного из следующих методов:

    • Object.wait без тайм-аута
    • Присоединиться без таймаута
    • LockSupport.park

    Поток в состоянии ожидания ожидает, пока другой поток выполнит определенное действие.

    Тип константы: время ожидания

    Описание: состояние потока для ожидающего потока с указанным временем ожидания. Поток находится в состоянии ожидания по времени из-за вызова одного из следующих методов с указанным положительным временем ожидания:

    • Thread.sleep
    • Object.wait с таймаутом
    • Присоединиться к таймауту
    • LockSupport.parkNanos
    • LockSupport.parkUntil
  • Постоянный тип: прекращено

    Описание: состояние потока для завершенного потока. Поток завершил выполнение.

    // Java-программа для демонстрации состояний потоков

    class thread implements Runnable

    public void run()

    // переводим thread2 в состояние ожидания по времени

    catch (InterruptedException e)

    System.out.println( «State of thread1 while it called join() method on thread2 -» +

    catch (InterruptedException e)

    public class Test implements Runnable

    public static Thread thread1;

    public static Test obj;

    public static void main(String[] args)

    thread1 = new Thread(obj);

    // thread1 создан и в настоящее время находится в состоянии NEW.

    System.out.println( «State of thread1 after creating it — » + thread1.getState());

    // thread1 перешел в состояние Runnable

    System.out.println( «State of thread1 after calling .start() method on it — » +

    public void run()

    thread myThread = new thread();

    Thread thread2 = new Thread(myThread);

    // thread1 создан и в настоящее время находится в состоянии NEW.

    System.out.println( «State of thread2 after creating it — » + thread2.getState());

    // thread2 перешел в состояние Runnable

    System.out.println( «State of thread2 after calling .start() method on it — » +

    // переводите thread1 в состояние ожидания по времени

    // переводите thread1 в состояние ожидания по времени

    catch (InterruptedException e)

    System.out.println( «State of thread2 after calling .sleep() method on it — » +

    // ожидаем смерти thread2

    catch (InterruptedException e)

    System.out.println( «State of thread2 when it has finished it’s execution — » +


    Объяснение: Когда создается новый поток, поток находится в состоянии NEW. Когда метод .start () вызывается в потоке, планировщик потока переводит его в состояние Runnable. Всякий раз, когда метод join () вызывается для экземпляра потока, текущий поток, выполняющий этот оператор, будет ожидать перехода этого потока в состояние Ter прекращено. Таким образом, перед тем как на консоли будет напечатан последний оператор, программа вызывает метод join () в потоке 2, заставляя поток 1 ждать, пока поток 2 завершит свое выполнение и будет переведен в состояние завершения. поток1 переходит в состояние ожидания, потому что он ожидает, когда поток 2 завершит свое выполнение, так как он вызвал соединение в потоке 2.

    Эта статья предоставлена Mayank Kumar . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи contribute@geeksforgeeks.org. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

    Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.

    Java Thread Methods and Thread States


    We have various methods which can be called on Thread class object. These methods are very useful when writing a multithreaded application. Thread class has following important methods. We will understand various thread states as well later in this tutorial.

    Thread States

    The thread scheduler’s job is to move threads in and out of the therunning state. While the thread scheduler can move a thread from the running state back to runnable, other factors can cause a thread to move out of running, but not back to runnable. One of these is when the thread’s run()method completes, in which case the thread moves from the running state directly to the dead state.


    This is the state the thread is in after the Thread instance has been created, but the start() method has not been invoked on the thread. It is a live Thread object, but not yet a thread of execution. At this point, the thread is considered not alive.


    This means that a thread can be run when the time-slicing mechanism has CPU cycles available for the thread. Thus, the thread might or might not be running at any moment, but there’s nothing to prevent it from being run if the scheduler can arrange it. That is, it’s not dead or blocked.


    This state is important state where the action is. This is the state a thread is in when the thread scheduler selects it (from the runnable pool) to be the currently executing process. A thread can transition out of a running state for several reasons, including because «the thread scheduler felt like it». There are several ways to get to the runnable state, but only one way to get to the running state: the scheduler chooses a thread from the runnable pool of thread.


    The thread can be run, but something prevents it. While a thread is in the blocked state, the scheduler will simply skip it and not give it any CPU time. Until a thread reenters the runnable state, it won’t perform any operations. Blocked state has some sub-states as below,

    • Blocked on I/O: The thread waits for completion of blocking operation. A thread can enter this state because of waiting I/O resource. In that case, the thread sends back to runnable state after the availability of resources.
    • Blocked for join completion: The thread can come in this state because of waiting for the completion of another thread.
    • Blocked for lock acquisition: The thread can come in this state because of waiting for acquire the lock of an object.


    A thread in the dead or terminated state is no longer schedulable and will not receive any CPU time. Its task is completed, and it is no longer runnable. One way for a task to die is by returning from its run( ) method, but a task’s thread can also be interrupted, as you’ll see shortly.

    Let’s take an example of Java program to demonstrate various thread state and methods of thread class.

    Tech Tutorials

    Tutorials and posts about Java, Spring, Hadoop and many more. Java code examples and interview questions. Spring code examples.

    Saturday, March 30, 2019

    Thread States (Thread Life Cycle) in Java Multi-Threading

    It is important to know the lifecycle of a thread in Java and various states a Java thread can be in. That will give an idea about what happens after creating a thread in Java and after calling the start() method on a thread. In this post we’ll see various Thread states in Java multi-threading.

    In order to begin execution of the thread’s run() method you need to call the start() method on the thread. That is when Java Virtual Machine calls the run method of the thread.

    Once scheduled to run by JVM a thread will run when its gets CPU cycle. A thread may be in waiting, blocked or running state after scheduled to run and later transitions to terminated state.

    Java thread states

    Thread states in Java or the Java thread cycle is as follows.

    When a thread is created either by extending Thread class or implementing Runnable interface it is in «New State«.

    When a thread is in «New» state it is not yet scheduled to run.

    When start() method is called on the thread object, that causes the thread to begin execution and it’s the Java Virtual Machine that calls the run() method of the thread.

    This thread state is called Runnable as thread may not start running as soon as the start() method is called. It depends on the native OS when it schedules the thread to start running. A thread starts running when it gets the CPU cycle. A running thread may change state to waiting, blocked, runnable again and terminated.

    When a resource is shared among various threads then a thread may go into blocked state as the resource may be used by another thread. In that case a thread has to suspend its execution because it is waiting to acquire a lock.
    As example in case of synchronized block where only one thread can enter that block of code.

    A thread in Java is also in blocked state when waiting for some IO to complete.

    A thread that is waiting indefinitely for another thread to perform a particular action is in the waiting state.
    As example A thread is waiting because of a call to wait() or join() method where no time of waiting is specified as parameter.

    A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
    As exp. A thread is waiting because of a call to wait() or join() method where time of waiting is specified as parameter. Calling sleep(long millis) will also result in a thread entering a TIMED_WAITING state.

    A thread that has exited is in terminated state. This happens when the thread has completed executing the run() method. A thread may also be terminated any time by calling its stop() method (note that Thread.stop() is deprecated and it is inherently unsafe)

    Getting thread’s state in Java

    Thread class has a method getState(), using that method you can get the current state of a thread. This method returns Thread.State enum which has constants for all the above mentioned thread states.

    That’s all for this topic Thread States in Java Multi-Threading. If you have any doubt or any suggestions to make please drop a comment. Thanks!

  • Ссылка на основную публикацию
    ВсеИнструменты 220 Вольт