Java threads life cycle

Java threads life cycle

• Introduction to Java
• The complete History of Java Programming Language
• C++ vs Java vs Python
• How to Download and Install Java for 64 bit machine?
• Setting up the environment in Java
• How to Download and Install Eclipse on Windows?
• JDK in Java
• How JVM Works – JVM Architecture?
• Differences between JDK, JRE and JVM
• Just In Time Compiler
• Difference between JIT and JVM in Java
• Difference between Byte Code and Machine Code
• How is Java platform independent?

• Decision Making in Java (if, if-else, switch, break, continue, jump)
• Java if statement with Examples
• Java if-else
• Java if-else-if ladder with Examples
• Loops in Java
• For Loop in Java
• Java while loop with Examples
• Java do-while loop with Examples
• For-each loop in Java
• Continue Statement in Java
• Break statement in Java
• Usage of Break keyword in Java
• return keyword in Java

• Object Oriented Programming (OOPs) Concept in Java
• Why Java is not a purely Object-Oriented Language?
• Classes and Objects in Java
• Naming Conventions in Java
• Java Methods
• Access Modifiers in Java
• Java Constructors
• Four Main Object Oriented Programming Concepts of Java
• Inheritance in Java
• Abstraction in Java
• Encapsulation in Java
• Polymorphism in Java
• Interfaces in Java
• ‘this’ reference in Java

Источник

Java Thread Life Cycle and States

In Java, a Thread is a lightweight process that allows a program to operate more efficiently by running multiple threads in parallel. Internally, JVM creates a Thread and hands it over to the operating system for execution. The operating system then schedules, executes this thread and performs various state transitions between multiple threads.

During state transitions and life cycle, a Thread goes into various states depending on several factors such as thread priority, forcibly suspending a thread or waiting for the output of blocking operations.

1. Thread Life Cycle States

A Java thread can be in any of the following thread states during its life cycle:

• New
• Runnable (or Running)
• Blocked
• Waiting
• Timed Waiting
• Terminated

These are also called life cycle events of a thread. Let’s understand each state in more detail.

As soon as, you create new thread , it’s in NEW state. Thread remains in New state until the program starts the thread using its start() method. At this point, the thread is not alive.

Thread thread = new Thread(); System.out.println(thread.getState()); //NEW

Calling the thread.start() method puts the thread in RUNNABLE state. At this point, execution control is passed to OS thread scheduler to finish its execution. The 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. Thread scheduling is platform dependent — the behavior of a multi-threaded program could vary across different Java implementations.

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.

Thread thread = new Thread(); thread.start(); System.out.println(thread.getState()); //RUNNABLE

The operating system hide the RUNNABLE and RUNNING states from the Java Virtual Machine (JVM), which sees only the RUNNABLE state.

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.

Usually program put a thread in WAIT state because something else needs to be done prior to what current thread is doing. A thread can be put in waiting state using

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

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 using following methods:

• thread.sleep(long millis)
• wait(int timeout) or wait(int timeout, int nanos)
• thread.join(long millis)

Such a thread returns to the RUNNABLE state when it is 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.

2. Deadlock and Starvation

Please remember that though JVM and OS thread scheduler do their best yet sometimes threads can cause starvation or deadlock.

A deadlock occurs when a waiting thread (let us call this thread1) cannot proceed because it is waiting (either directly or indirectly) for another thread (let us call this thread2) to proceed. And simultaneously thread2 cannot proceed because it is waiting (either directly or indirectly) for thread1 to proceed.

In this Java concurrency tutorial, we learned about the lifecycle of a Thread in Java, and how the state transitions happen between different states of the Thread.

Источник

Thread Life Circle, состояние объекта Thread

Мы начинаем новую тему – работа с нитями или как их еще называют – тр э дами (от thread).

— А я слышал, что треды называют потоками.

— Да, такое название все еще употребляется, но постепенно выходит из моды. Проблема в том, что есть еще stream, который дословно переводится как «поток». Поэтому thread’ы принято называть нитями (дословный перевод) или программными потоками. В противовес stream’ам, которые называют потоками ввода-вывода.

Итак. Сегодня мы рассмотрим состояния объекта Thread, через которые он проходит (или может проходить) в процессе работы нити.

Сколько состояний ты можешь назвать прямо сейчас, Амиго?

— Два. Первое – это нить до вызова метода start(): объект есть, но нить еще не активна. И второе — после вызова метода start() – когда нить что-то делает, важное.

— Ты прав, такое разграничение есть, эти состояния называются new и running, но это только самое начало.

Во-первых, нить когда-нибудь заканчивает работу, а значит, может быть такая ситуация – объект Thread есть, но нить не в состоянии new и не в состоянии running. Такое состояние, когда нить завершила работу, называется terminated.

Но и это еще не все. Не стоит забывать, что в каждый момент времени работает только одна нить. А видимая одновременная работа – это постоянное перескакивание процессора с нити на нить. Для времени, когда нить как бы работает, а на самом деле ждет своей очереди, тоже есть отдельное состояние. Оно называется ready-to-run. Нить во время работы постоянно меняет состояние с running на ready и потом снова на running, когда становится активной.

Сразу после вызова метода start() нить получает статус ready-to-run, и помещается в общий список нитей, между которыми переключается Java-машина.

— Не так уж и сложно. До начала работы – состояние new, после окончания – terminated. А в процессе работы нить находится то в активном (running), то в пассивном (ready) режиме работы.

— Твоя краткость удивляет, но так и есть.

Но и это еще не все. Нить может быть заблокирована. Например, при входе в блок synchronized. Нить подошла к блоку кода, помеченному synchronized, а он занят другой нитью. Тогда наша нить получит состояние blocked и будет ждать освобождения объекта-мютекса.

Вот как выглядит эта ситуация с состояниями:

Но и это еще не все. Есть еще отдельное состояние, когда нить не blocked, но и не ready – это waiting. Например, при вызове методов join() у другой нити.

При вызове join() у объекта другой нити, наша нить как-бы «присоединяется к ней», а на деле – просто ждет ее завершения.

Кроме того, есть еще метод wait(), (из набора wait, notify, notifyAll), вызов которого тоже переводит нить в состояние waiting.

— Подожди! Но и это еще не все. Нить может спать, например, при вызове метода sleep. Для этого тоже есть отдельное состояние «timed waiting». «timed waiting» значит, что нить чего-то ждет ограниченное время. Если вызвать метод wait с параметром — wait(timeout) или join(timeout), то нить перейдет в состояние timed waiting.

Так что вот тебе полная схема:

— Гм. Это все? Или там есть еще 10 новых интересных состояний?

На самом деле – можешь запомнить только первую схему – она проще. Но вторая точнее.

Как ни странно – в интернете очень много схем состояний Thread и они все разные.

Поэтому я и привела тебе эту схему – она самая полная и правильная.

На этой схеме состояния ready и running объединены в единый блок – runnable, и знаешь почему?

— Нет. Я же в первый раз это все вообще вижу.

— У класса Thread есть внутренний класс State, а также метод public State getState().

public enum State < NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; >

Ты всегда можешь вызвать у объекта типа Thread метод getState() и узнать его текущее состояние. И, конечно, оно будет одним из значений enum State.

— Ясно. То есть настоящие состояния внутри Java-машины, а есть состояния, которые можно получить из Java-кода с помощью метода State getState().

А в каких ситуациях я буду это использовать?

Но знать о том, что происходит при работе внутри нити, ты обязан. Иначе на твоем пути будет много ошибок, и ты даже не будешь догадываться об их причине.

Кроме того, состояния Thread очень любят спрашивать на собеседованиях.

Источник

Thread Life Cycle in Java — Thread States in Java

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Understanding Thread Life Cycle in Java and Thread States are very important when you are working with Threads and programming for multithreaded environment. From our last tutorial, we can create a java thread class by implementing Runnable interface or by extending Thread class, but to start a java thread, we first have to create the Thread object and call it’s start() method to execute run() method as a thread.

Thread Life Cycle in Java

Below diagram shows different states of thread life cycle in java. We can create a thread in java and start it but how the thread states change from Runnable to Running to Blocked depends on the OS implementation of thread scheduler and java doesn’t have full control on that.

New

When we create a new Thread object using new operator, thread state is New Thread. At this point, thread is not alive and it’s a state internal to Java programming.

Runnable

When we call start() function on Thread object, it’s state is changed to Runnable. The control is given to Thread scheduler to finish it’s execution. Whether to run this thread instantly or keep it in runnable thread pool before running, depends on the OS implementation of thread scheduler.

Running

When thread is executing, it’s state is changed to Running. Thread scheduler picks one of the thread from the runnable thread pool and change it’s state to Running. Then CPU starts executing this thread. A thread can change state to Runnable, Dead or Blocked from running state depends on time slicing, thread completion of run() method or waiting for some resources.

Blocked/Waiting

A thread can be waiting for other thread to finish using thread join or it can be waiting for some resources to available. For example producer consumer problem or waiter notifier implementation or IO resources, then it’s state is changed to Waiting. Once the thread wait state is over, it’s state is changed to Runnable and it’s moved back to runnable thread pool.

Dead

Once the thread finished executing, it’s state is changed to Dead and it’s considered to be not alive. Above are the different states of thread. It’s good to know them and how thread changes it’s state. That’s all for thread life cycle in java.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases. Learn more about us

Источник