很遗憾，没有一篇文章能讲清楚线程的生命周期！

public enum State {    /**     * 新建状态，线程还未开始     */    NEW,
    /**     * 可运行状态，正在运行或者在等待系统资源，比如CPU     */    RUNNABLE,
    /**     * 阻塞状态，在等待一个监视器锁（也就是我们常说的synchronized）     * 或者在调用了Object.wait()方法且被notify()之后也会进入BLOCKED状态     */    BLOCKED,
    /**     * 等待状态，在调用了以下方法后进入此状态     * 1. Object.wait()无超时的方法后且未被notify()前，如果被notify()了会进入BLOCKED状态     * 2. Thread.join()无超时的方法后     * 3. LockSupport.park()无超时的方法后     */    WAITING,
    /**     * 超时等待状态，在调用了以下方法后会进入超时等待状态     * 1. Thread.sleep()方法后【本文由公从号“彤哥读源码”原创】     * 2. Object.wait(timeout)方法后且未到超时时间前，如果达到超时了或被notify()了会进入BLOCKED状态     * 3. Thread.join(timeout)方法后     * 4. LockSupport.parkNanos(nanos)方法后     * 5. LockSupport.parkUntil(deadline)方法后     */    TIMED_WAITING,
    /**     * 终止状态，线程已经执行完毕     */    TERMINATED;}

public class ThreadLifeTest {    public static void main(String[] args) throws IOException {        Object object = new Object();        ReentrantLock lock = new ReentrantLock();        Condition condition = lock.newCondition();
        new Thread(()->{            synchronized (object) {                try {                    System.out.println("thread1 waiting");                    object.wait();//                    object.wait(5000);                    System.out.println("thread1 after waiting");                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "Thread1").start();
        new Thread(()->{            synchronized (object) {                try {                    System.out.println("thread2 notify");                    // 打开或关闭这段注释，观察Thread1的状态//                    object.notify();【本文由公从号“彤哥读源码”原创】                    // notify之后当前线程并不会释放锁，只是被notify的线程从等待队列进入同步队列                    // sleep也不会释放锁                    Thread.sleep(10000000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "Thread2").start();
        new Thread(()->{            lock.lock();            System.out.println("thread3 waiting");            try {                condition.await();//                condition.await(200, (TimeUnit).SECONDS);                System.out.println("thread3 after waiting");            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                lock.unlock();            }        }, "Thread3").start();
        new Thread(()->{            lock.lock();            System.out.println("thread4");            // 打开或关闭这段注释，观察Thread3的状态//            condition.signal();【本文由公从号“彤哥读源码”原创】            // signal之后当前线程并不会释放锁，只是被signal的线程从等待队列进入同步队列            // sleep也不会释放锁            try {                Thread.sleep(1000000);            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                lock.unlock();            }        }, "Thread4").start();
    }}