How to distinguish RUNNING state from java.lang.Thread.State.RUNNABLE in Java

When a thread is RUNNABLE, it can be running, or be not. Is there a way to distinguish it from java.lang.Thread.State#RUNNABLE?

All states of threads in Java doc:

java.lang public class Thread.State

extends Enum

A thread state. A thread can be in one of the following states:

NEW A thread that has not yet started is in this state.

RUNNABLE A thread executing in the Java virtual machine is in this state.

BLOCKED A thread that is blocked waiting for a monitor lock is in this state.

WAITING A thread that is waiting indefinitely for another thread to perform a particular action is in this state.

TIMED_WAITING A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.

TERMINATED A thread that has exited is in this state.

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.

package bj.thread;

public class ThreadApp2 {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getState());
    }
}

The output:

RUNNABLE

Answer

Suppose that the Thread class defined a function, boolean isRunning(). What could you do with it? This, for example, would be meaningless:

if (t.isRunning()) {
    doXYandZ();
}

The problem with it is, even if thread t actually was RUNNING at some point during the isRunning() call, there’s no guarantee that it will still be running by the time t.isRunning() returns true. The is no guarantee that it won’t stop running sometime during the doXYandZ() call.

The operating system is able to distinguish between threads that are RUNNING and threads that are not because that state is controlled by the operating system, and the operating system needs to remember which threads are RUNNING and which are not because it’s the operating system’s job to schedule them.

The Java Runtime Environment doesn’t distinguish between RUNNING and RUNNABLE because it doesn’t control which threads are are actually RUNNING at any given time, and it would have no way to meaningfully react to changes in that state.