深入java多线程，多线程状态及转换

1、线程状态值

在一个时间点，每个线程有且只有一种状态，反应线程当前的状况。

在Thread类中用枚举定义了线程的6中状态：

/**
     * A thread state.  A thread can be in one of the following states:
     */
    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;
    }

 分别是NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED。

状态	名词	说明
NEW	new：新建/初始状态	新建好了的线程对象，未调用start()启动线程
RUNNABLE	runnable：运行状态	线程对象调用了start()后，线程处于运行状态。调用start()后由于处理器资源，线程可能不能立即分配到cpu资源开始运行，运行状态又分为运行中（running）和就绪（ready）两种状态，就绪状态的线程在获得CPU时间片后变为运行中状态。
BLOCKED	blocked：阻塞状态	线程在进入synchronized关键字修饰的方法或代码块（需要获取锁）时的状态，等待获取到锁的过程。
WAITING	waiting：等待状态	线程对象调用了wait()后的状态，释放同步锁，一直处于等待被显式地唤醒的状态，否则会处于无限期等待的状态。就好比你先去墙角反省，直到我叫你。
TIMED_WAITING	timed_waiting：超时等待状态	线程调用Thread.sleep(long millis)进入超时等待状态，sleep()方法是Thread类的静态本地native方法，它不会释放同步锁，等待指定时长后自动唤醒运行，无需主动去唤醒。
TERMINATED	terminated：终止状态	当线程的run()方法完成时，或者主线程的main()方法完成时，就处于终止状态。线程终止后不能再复生。通常来说就是代码已经执行完毕。

 

2、线程转换

线程状态转换图

 

 

 

 

 

 

• 新建线程：有三种方式新建线程对象，分别是继承Thread类重写run()方法，实现Runnable接口重写其run()方法，实现Callable接口且有返回值。
• 运行状态：运行状态包括就绪状态和运行中状态。就绪状态也称准备状态或者可执行状态。线程对象创建后，调用该线程对象的start()方法，线程为可执行状态，等待获取cup运行资源。在cpu调度资源后开始执行，变为运行中状态。运行中的线程在时间片用完或者调用Thread.yield()方法的情况下会进入就绪状态。Thread.yield()方法翻译为让步，就是说一个线程调用这个方法后，它就会把自己cpu执行的时间让掉，退出cpu运行，再与其他线程共同争取cpu运行资源，并不是让给其他线程，只是让出，再同时一起竞争。
• 超时等待状态：运行中的线程调用了以下方法会进入超时等待状态：Thread.sleep(long millis)；Object.wait(long)；thread.join(long)。当线程过了等待时长后自动变为运行状态，或者调用Object.notifly()、Object.notiflyAll()方法。thread.join(long)方法为Thread类的非静态方法，线程对象才能调用。thread2.join()为确保thread2执行完，thread2.join(2000)为等待thread2执行2000ms，不管是否执行完毕。
• 等待状态：处于等待中的线程需主要的去唤醒，否则将一直处于等待状态。运行状态的线程调用了Object.wait()、Thread.join()方法进入等待状态，调用Object.notifly()、Object.notiflyAll()方法唤醒线程，进入运行状态。超时等待和等待状态一大区别为等待状态的线程不会释放同步资源，超时等待线程会释放同步资源。分别对应的是wait()和sleep(long)方法。
• 阻塞状态：当运行的线程遇到了需要取得锁的代码块或者方法，即为synchronized修饰的，在获取不到锁的情况下，线程进入阻塞状态，等待其他线程释放锁，当获取到锁是线程就进入运行状态，可见，线程阻塞在多线程中是比较常见的场景。
• 终止状态：当线程执行完，走完run方法或者主线程main执行完，线程变为终止状态。