一.概述
Java中所有多线程的实现，均通过封装Thread类实现，所以通过源码深入研究Thread类，对深入理解java多线程很有必要，本文Thread类源码均基于JDK 1.8。
二.线程的状态
通过Thread类的内部枚举类State可以知道， 线程有以下六个状态。
public enum State {
/**
* 线程刚创建，尚未启动（还未调用 start() 方法）的状态
*/
NEW,
/**
* 可运行线程的线程状态。调用了 start() 方法，此时线程已经准备好被执行，处于就绪队列中。
* 处于此状态的线程是正在JVM中运行的，但可能在等待操作系统中的其他资源，如CPU时间片。
*/
RUNNABLE,
/**
* 阻塞等待监视器锁的状态。处于此状态的线程正在阻塞等待监视器锁，以进入一个同步块/方法，
* 或者在执行完wait()方法后重入同步块/方法。
*/
BLOCKED,
/**
* 等待状态。执行完Object.wait无超时参数操作，或者 Thread.join无超时参数操作，
* 或者 LockSupport.park操作后，线程进入等待状态。
* 一般在等待状态的线程在等待其它线程执行特殊操作，例如：
* 等待其它线程调用Object.notify()唤醒或者Object.notifyAll()唤醒所有。
*/
WAITING,
/**
* 计时等待状态。Thread.sleep、Object.wait带超时时间、Thread.join带超时时间、
* LockSupport.parkNanos、LockSupport.parkUntil这些操作会使线程进入计时等待状态。
*/
TIMED_WAITING,
/**
* 终止状态，线程执行完毕。
*/
TERMINATED;
}
通过下面的线程状态转换图，可以对线程状态的转换有更深刻的认识：
创建状态（New）
当用new操作符创建一个新的线程对象时，该线程处于创建状态，尚未启动（还未调用 start() 方法）。
处于创建状态的线程只是一个空的线程对象，系统不为它分配资源。可运行状态（Runnable）
处于创建状态的线程调用start()方法，系统将为线程分配必需的资源（JVM会为其创建程序计数器和方法调用栈），则此线程进入可运行状态。
线程处于可运行状态只说明它具备了运行条件，但可运行状态并不一定是正在运行的状态。一个线程能否由可运行状态变为运行状态，取决于系统的调度。运行状态（Running）
处于可运行状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列（尽管是采用队列形式，事实上，把它称为可运行池而不是可运行队列。因为cpu的调度不一定是按照先进先出的顺序来调度的），等待系统为其分配CPU。
一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。不可运行状态（Waiting/Blocked/Timed Waiting）
处于运行状态的线程最为复杂，它可以变为可运行状态和不可运行状态。例如，对运行状态的线程调用yield()方法，它就会让出cpu资源，再次变为可运行状态。
当发生下列事件时，处于运行状态的线程会转入到不可运行状态：
(1)当线程调用wait()方法来等待另一个线程的通知，或者等待另一个调用join()方法的线程执行结束时，线程就会进入等待状态。
(2)当一个线程试图获取一个内部的对象锁，而该锁被其他线程持有，则该线程进入阻塞状态。
(3)当线程调用sleep()方法时，传递一个超时参数，则会使线程进入计时等待状态。
返回可运行状态：
(1)通知消息到来或另一个调用join()方法的线程执行结束时,线程会进入可运行状态。
(2)当其他线程释放对象锁，并且线程调度器允许本线程持有该锁时，该线程将变为可运行状态。
(3) 处于计时等待状态的线程在指定的时间过去后，会变为可运行状态。死亡状态
线程正常结束或因异常退出run()方法，线程进入死亡状态。
线程一旦进入死亡状态，将不再具有运行的资格，所以也不可能再转到其他状态。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
线程会通过以下三种方式进入死亡状态：
(1)run()方法执行完成，线程正常结束。
(2)线程抛出一个未捕获的Exception或Error。
(3)直接调用stop()方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，容易导致死锁）。
三.基本属性
Thread类中的基本属性如下所示。
/* Make sure registerNatives is the first thing does. */
// 类加载的时候，调用静态的registerNatives()方法， 这个方法是本地方法
private static native void registerNatives();
static {
registerNatives();
}
//线程名字
private volatile String name;
//线程优先级
private int priority;
private Thread threadQ;
private long eetop;
//是否是单步执行
private boolean single_step;
//是否是守护线程
private boolean daemon = false;
//JVM状态
private boolean stillborn = false;
//从构造方法传过来的Runnable，实际要执行的线程任务
private Runnable target;
//当前线程所在的线程组
private ThreadGroup group;
//当前线程的上下文类加载器
private ClassLoader contextClassLoader;
//当前线程继承的访问控制上下文
private AccessControlContext inheritedAccessControlContext;
//线程的默认编号，用于生成线程的默认名字
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
//当前线程维护的ThreadLocal值，ThreadLocalMap会被ThreadLocal类维护
ThreadLocal.ThreadLocalMap threadLocals = null;
//当前线程维护的从父线程那里继承的ThreadLocal值
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
//给这个线程设置的栈的大小,默认为0
private long stackSize;
private long nativeParkEventPointer;
// 线程id
private long tid;
//用于生成线程id
private static long threadSeqNumber;
//标识线程状态，默认是线程未启动
private volatile int threadStatus = 0;
//得到下个线程id
private static synchronized long nextThreadID() {
return ++threadSeqNumber;
}
volatile Object parkBlocker;
private volatile Interruptible blocker;
private final Object blockerLock = new Object();
//设置blocker字段
void blockedOn(Interruptible b) {
synchronized (blockerLock) {
blocker = b;
}
}
//线程执行的最低优先级
public final static int MIN_PRIORITY = 1;
//线程执行的默认优先级
public final static int NORM_PRIORITY = 5;
//线程执行的最高的优先级
public final static int MAX_PRIORITY = 10;
四.构造方法
要创建一个Thread类的实例自然要通过构造函数，Thread类的public构造函数有8个之多，但是他们本质上都调用了同一个init函数:
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
init(null, null, name, 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {
init(group, target, name, stackSize);
}
可见，这八个public类型的构造函数只不过是给init的方法的四个参数分别赋不同的值, 这四个参数分别是:
- ThreadGroup g（线程所在线程组）
- Runnable target （Runnable对象）
- String name （线程的名字）
- long stackSize （为线程分配的栈的大小，若为0则表示忽略这个参数）
而init方法又调用了另一个init方法，设置了AccessControlContext，以及inheritThreadLocals参数:
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
//获取父线程
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
//判断线程组参数是否为空
if (g == null) {
//如果没有传入线程组的话， 首先使用SecurityManager中的ThreadGroup
if (security != null) {
g = security.getThreadGroup();
}
//如果从SecurityManager中获取不到ThreadGroup， 那么就从父线程中获取线程组
if (g == null) {
g = parent.getThreadGroup();
}
}
g.checkAccess();
if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
g.addUnstarted();
//初始化线程组
this.group = g;
//子线程继承父线程的优先级和守护属性
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
//初始化target
this.target = target;
//设置优先级
setPriority(priority);
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
//设置栈深度
this.stackSize = stackSize;
//设置线程ID
tid = nextThreadID();
}
五.native方法
//获得当前正在执行的线程的引用
public static native Thread currentThread();
//使当前线程从运行状态（Running）变为可运行状态（Runnable）
public static native void yield();
//强制当前正在执行的线程休眠（暂停执行），休眠结束后，线程返回到可运行状态
public static native void sleep(long millis) throws InterruptedException;
//启动线程，为线程分配对应的资源
private native void start0();
//查看当前线程是否被中断
private native boolean isInterrupted(boolean ClearInterrupted);
//查看当前线程是否存活
public final native boolean isAlive();
//获取当前线程栈帧的数量
public native int countStackFrames();
//当且仅当当前线程在指定的对象上持有监视器锁时，才返回 true
public static native boolean holdsLock(Object obj);
private native static StackTraceElement[][] dumpThreads(Thread[] threads);
private native static Thread[] getThreads();
//设置线程优先级
private native void setPriority0(int newPriority);
//停止线程
private native void stop0(Object o);
//挂起线程
private native void suspend0();
//将一个挂起线程复活继续执行
private native void resume0();
//设置该线程的中断状态
private native void interrupt0();
private native void setNativeName(String name);
六.主要方法
1.start()方法
public synchronized void start() {
//线程只能被启动一次，不能被重复启动，如果线程已启动则抛出异常
if (threadStatus != 0)
throw new IllegalThreadStateException();
//向线程组中添加此线程
group.add(this);
boolean started = false;
try {
//调用native方法
start0();
started = true;
} finally {
try {
if (!started) {
// 如果线程启动失败，从线程组里面移除该线程
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
synchronized 关键字说明start方法是同步的，并且是启动这个线程进行执行，JVM将会调用这个线程的run方法。这样产生的结果是，两个线程在并发执行，其中一个是调用start()方法的线程，另一个是当前thread对象代表的线程，它会执行run方法。
2.sleep()方法
public static void sleep(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
//调用本地方法
sleep(millis);
}
sleep()方法的作是使当前线程休眠一定的时间，让其他线程有机会继续执行，但是这个期间是不释放持有的锁的，调用sleep()方法需要捕捉异常。
3.join()方法
join()方法的实现原理，可以看我之前写的一篇文章：Thread类中join方法的实现原理
4.interrupt()方法
public void interrupt() {
if (this != Thread.currentThread())
//检查权限
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
//只是设置了中断标志位
interrupt0();
b.interrupt(this);
return;
}
}
interrupt0();
}
其实调用interrupt()方法并不是真的中断线程，只是将Thread中的interrupt标志设置为true，用户需自行检测这一变量，停止线程。
其实Thread类中与线程中断有关的，有三个方法，比较容易混淆，在这里解释一下。
public void interrupt() //将线程设置为中断状态
public boolean isInterrupted() //判断是否被中断
public static boolean interrupted() //判断是否被中断，被清除当前中断状态
一般来说，阻塞函数：如Thread.sleep、Thread.join、Object.wait等在检查到线程的中断状态的时候，会抛出InteruptedExeption, 也就是说，它可以用来中断一个正处于阻塞状态的线程，同时会清除线程的中断状态。
5.exit( )方法
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
target = null;
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
exit( )是由系统调用的，用于线程在真正的退出前进行一些清理的操作。
参考：
Thread类源码分析
Java常用类源码——Thread源码解析
Thread类源码解读(1)——如何创建和启动线程