线程

什么是线程？

线程：进程中的最小执行单元

如何创建线程？创建线程的两种方式

• 继承Thread类

static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("t1");
        }
}

• 实现Runable接口

    static class Thread02 implements Runnable {
        @Override
        public void run() {
            System.out.println("t2");
        }
    }

线程几种状态

1. 新建状态（NEW）

通过以上两种方式可以创建一个线程出来；

2. 就绪状态（RUNNABLE）

调用线程的start()方法可以进入就绪状态；可运行等待获取os系统资源；

3. 阻塞状态（BLOCKED）

• 同步阻塞
  running状态下的线程在需要获取synchronized的时候等待其他线程释放锁的情况，该线程将会被放入锁池
• 等待阻塞
  running状态下的线程调用o.await()方法时候，该线程将进入等待队列，等待唤醒
• 其他
  线程调用sleep方法等

4. 运行状态（RUNNING）

就绪状态下的线程在获得CPU的时间切片抢占到CPU的资源以后，进入运行状态；

5. 死亡状态（DEAD）

运行状态下，run()方法或者main方法调用结束，线程进入死亡状态；线程的生命周期也就结束了！

JDK源码中线程的状态

以下是jdk源码中对线程状态的描述，分为新生，可运行，阻塞，等待，永久等待，终止状态；

	/**
	 * 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;