/**     * Causes this thread to begin execution; the Java Virtual Machine      * calls the <code>run</code> method of this thread.      * <p>     * The result is that two threads are running concurrently: the      * current thread (which returns from the call to the      * <code>start</code> method) and the other thread (which executes its      * <code>run</code> method).      * <p>     * It is never legal to start a thread more than once.     * In particular, a thread may not be restarted once it has completed     * execution.     *     * @exception  IllegalThreadStateException  if the thread was already     *               started.     * @see        #run()     * @see        #stop()     */    public synchronized void start() {        /**     * This method is not invoked for the main method thread or "system"     * group threads created/set up by the VM. Any new functionality added      * to this method in the future may have to also be added to the VM.     *     * A zero status value corresponds to state "NEW".         */        if (threadStatus != 0 || this != me)            throw new IllegalThreadStateException();        group.add(this);        start0();        if (stopBeforeStart) {        stop0(throwableFromStop);    }    }    private native void start0();

import java.lang.Thread.State;public class ThreadStausTravel {    public static void main(String[] args) {        State[] status=Thread.State.values();        for (State state : status) {            System.out.println(state.name()+"==>"+state.ordinal());        }    }}

    /**     * A thread state.  A thread can be in one of the following states:      * <ul>     * <li>{@link #NEW}<br>     *     A thread that has not yet started is in this state.     *     </li>     * <li>{@link #RUNNABLE}<br>     *     A thread executing in the Java virtual machine is in this state.      *     </li>     * <li>{@link #BLOCKED}<br>     *     A thread that is blocked waiting for a monitor lock      *     is in this state.      *     </li>     * <li>{@link #WAITING}<br>     *     A thread that is waiting indefinitely for another thread to      *     perform a particular action is in this state.      *     </li>     * <li>{@link #TIMED_WAITING}<br>     *     A thread that is waiting for another thread to perform an action      *     for up to a specified waiting time is in this state.      *     </li>     * <li>{@link #TERMINATED}<br>      *     A thread that has exited is in this state.     *     </li>     * </ul>     *     * <p>     * 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.     *      * @since   1.5     * @see #getState     */    public enum State {        /**         * Thread state for a thread which has not yet started.         */        NEW,                /**         * Thread state for a runnable thread.  A thread in the runnable         * state is executing in the Java virtual machine but it may         * be waiting for other resources from the operating system         * such as processor.         */        RUNNABLE,                /**         * Thread state for a thread blocked waiting for a monitor lock.         * A thread in the blocked state is waiting for a monitor lock         * to enter a synchronized block/method or          * reenter a synchronized block/method after calling         * {@link Object#wait() Object.wait}.         */        BLOCKED,            /**         * Thread state for a waiting thread.         * A thread is in the waiting state due to calling one of the          * following methods:         * <ul>         *   <li>{@link Object#wait() Object.wait} with no timeout</li>         *   <li>{@link #join() Thread.join} with no timeout</li>         *   <li>{@link LockSupport#park() LockSupport.park}</li>         * </ul>         *          * <p>A thread in the waiting state is waiting for another thread to         * perform a particular action.           *         * For example, a thread that has called <tt>Object.wait()</tt>         * on an object is waiting for another thread to call          * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on          * that object. A thread that has called <tt>Thread.join()</tt>          * is waiting for a specified thread to terminate.         */        WAITING,                /**         * Thread state for a waiting thread 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:         * <ul>         *   <li>{@link #sleep Thread.sleep}</li>         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>         *   <li>{@link #join(long) Thread.join} with timeout</li>         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>          *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>         * </ul>         */        TIMED_WAITING,        /**         * Thread state for a terminated thread.         * The thread has completed execution.         */        TERMINATED;    }    /**     * Returns the state of this thread.     * This method is designed for use in monitoring of the system state,     * not for synchronization control.     *      * @return this thread‘s state.     * @since 1.5     */    public State getState() {        // get current thread state        return sun.misc.VM.toThreadState(threadStatus);    }

   /**     * If this thread was constructed using a separate      * <code>Runnable</code> run object, then that      * <code>Runnable</code> object‘s <code>run</code> method is called;      * otherwise, this method does nothing and returns.      * <p>     * Subclasses of <code>Thread</code> should override this method.      *     * @see     #start()     * @see     #stop()     * @see     #Thread(ThreadGroup, Runnable, String)     */    public void run() {    if (target != null) {        target.run();    }    }