JAVA 线程相关的概念

JAVA 线程基础

本文仅是本人理解，有不对的地方，欢迎留言批评指正

线程状态

初始状态

 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;
    }

上面是 JDK 源码定义的线程状态

• NEW：新建状态，初始状态
• RUNNABLE：可执行状态，得到 CPU 调度后就可以执行
• BLOCKED：阻塞状态，比如未获取到锁、调用了 wait 方法进入等待阻塞状态、调用了 sleep 方法进入了休眠等待状态
• WAITING：调用了 wait 方法进入的状态
• TIMED_WAITING：调用了 sleep 方法，还未到达时间前，线程的状态
• TERMINATED：终止状态

线程状态变化

变化图仅是个人理解：

变化图解析：

• 初始状态 new: 线程创建完毕，还未调用 start 方法前的状态。
• ready 和 running 状态：这 2 个状态都是运行状态，在 ready 状态的线程，在获取到 CPU 执行之间之后就进入 running 状态；cpu 时间片到了或者被其他线程争夺了 cpu 时间片，则该线程进入到 ready 状态。也可以是当前线程主动调用 yield( )方法，让给其他线程时间片去执行。
• 在运行状态中的线程，当调用 Object.wait()方法、Object.join()方法、LockSupport.park()方法，则该线程进入阻塞 waiting 状态；当其他线程调用了 Object.notify()、Object.notifyAll()方法、LockSupport.unpark(Thread t)方法，则此线程进入到了 ready 状态，也就是进入到了等待队列。
• 在运行状态的线程，当执行完线程所有工作、或者发生异常，但是没有捕获到异常的情况下，线程进入到 TERMINATED(终止)状态。
• • 在运行状态的线程，当需要和其他线程竞争锁资源时，则此线程未获得锁就进入阻塞状态（blocked 状态），比如竞争 Synchronized 关键字修饰的方法或者 Synchronized 修饰的代码块，此线程进入到了同步队列，所有竞争该锁的线程都会先进入同步队列，当某一个线程获取到锁，则该线程进入运行状态（在 ready 状态和 running 状态来回切换，直到该线程释放锁，走出 Synchronized 代码块或方法）。如果获取到了竞争锁，则该线程继续运行。
• 在运行状态的线程，当调用 Thread.sleep(long)、Object.wait(long）、Object.join(long)、LockSupport.parkNanos( long) 、LockSupport.parkUtil( long 从 1970.1.1 到将来某个时间的毫秒数 ) ，则此线程进入超时等待状态（time_waiting）；当此线程被其他线程调用 Object.notify()、Object.notifyAll()、LockSupport.unpark(Thread t) 时，则此线程进入运行状态。

线程竞争锁资源图解

(方框为等待队列，带波浪线的框为同步队列，圆圈为线程，大长方形为对象，小正方形为对象锁)

起初等待队列中有 4、3、2 线程，同步队列中有 6、5 线程，这些线程都需要“最终获取到对象锁才能执行完毕”，首先 1 线程获得了对象的锁， 它正在执行步骤：

1、线程执行到某一个时刻

2、它调用了wait()方法，自己进入了超时等待状态。

3、1线程而且释放了自己占用的锁资源对象 

4、同步队列中的线程开始竞争锁资源 

5、5线程争抢到了对象锁的资源 

6、5线程在执行的过程中，主动调用了notifyAll()方法，唤醒了所有线程，使所有线程都进入到了同步队列

7、5线程执行完毕Synchronized包含的逻辑，释放了锁资源 

8、同步队列中的6、4、3、2、1线程都可以竞争锁资源

线程中几个方法的对比

• Thread.sleep(long time)方法，睡眠指定时间（毫秒），不会释放对象锁。
• Thread.yield()方法，当前线程让步给其他线程执行，但是可能又会被重新选中到 CPU 执行。
• Thread.wait(long time) ,释放锁资源，到了 time 的毫秒数，进入同步队列重新竞争锁资源。
• Thread.join(long time) ,当前线程调用其他线程的 join 方法，自己进入 waiting/time_waiting 状态，其他线程执行完毕，或者到了 time 的时间，当前线程进入就绪（ready）状态。当前线程不会释放锁资源。
• obj.notify()和 obj.notifyAll()方法，唤醒锁对象等待队列中的线程，notify()是唤醒任意一个，notifiyAll()是唤醒所有。