第十九章 Java线程之Thread源码分析

前言

本章将会围绕下面几个问题展开分析：
线程是什么？
java中的线程状态有几种？
各个方法会对线程产生什么影响？

概念

线程是一种轻量级进程，而进程又被称为正在进行的程序。所以线程就是程序代码run起来的样子。就像一个田径赛场的运动员，程序的运行长度就是它的跑道长度，刚刚开始跑的时候，精力充沛，跑道中间的时候，体力下降，遇到障碍物了，摔倒一跤…等等。
所以，跑起来的程序，也就是线程它在不同阶段可能会有不同的状态。
线程是一种操作系统层面的定义，并非java创造，Java作为一种程序语言，只是实现了线程的概念和操作，所以要深刻理解线程还需要去啃计算机操作系统理论。

生命周期

在Thread源代码中，State是它的内部枚举，一共定义了六种状态：
NEW （就绪）
RUNABLE （运行）
BLOCKED （阻塞）
WAITING （等待）
TIMED_WAITING（限时等待）
TERMINATED**（结束）
这六种状态与计算机操作系统中定义的状态有些区别，一般来说，操作系统对一个线程的状态定义有六种：
起始
就绪
运行
等待
挂起
结束
为什么Java中定义的六种状态和操作系统的定义的状态不匹配呢？
因为它们的角度不一样。在操作系统中，状态的定义是围绕是否在CPU上运行，java中的定义是是否在JVM上运行。所以造成了两种状态定义的差异。
这种差异带来的不同主要是就绪、运行和等待三个主要状态。
因为，进入JVM后，线程状态是RUNABLE，但是在JVM中不代表在CPU上运行了，也可能JVM才把线程交到操作系统的排队队列中，也有可能运行了一段后被CPU切换了，重新进入了就绪等待下一次时间片。不论这个线程在操作系统中经过了多少次就绪、运行互相转换，这部分统统被JVM封装在RUNABLE状态中。
另外一点，操作系统中只有等待状态，当一个线程在CPU上运行到以某一刻，需要获取外部设备或其他事件时，为了提高计算机CPU的利用效率，CPU会让该线程先在一旁等待。这个动作称为运行状态到等待状态的转换。线程进入等待后，操作系统就没有再细化区分了，但是Java做了区分，它根据等待的不同时间，又分为了：
BLOCKED （阻塞）
WAITING （等待）
TIMED_WAITING（限时等待）
这三个等待对java来说有什么区别呢？
我的理解是主要针对java的设计产生了许多使用场景来区别的。如synchronized关键字，sleep方法、wait方法等等。

阻塞
它属于等待状态，它产生的场景一般在多线程环境中使用synchronized关键字，当一个线程没有抢到锁时，就会进入等待状态，此时，java叫它BLOCKED。
这种等待是不确定的，如果占有锁的线程一直不释放锁，那么阻塞的线程就会一直等待。直到锁被释放后，阻塞的状态才会结束，进入就绪状态重新竞争锁。

等待
它属于等待状态，它产生的场景一般在执行了wait（）方法后，需要其他线程调用notify 或 notifyAll 方法才能解除它等待状态。这种状态Java叫他WAITING。

限时等待
它属于等待状态，它的等待是一种有限的等待，是有时间限制的。一般产生于调用sleep（long time）方法中。它状态的解除不需要其他线程来参与。这种等待，Java叫它TIMED_WAITING。

那么具体这六个状态怎么产生的，怎么相互装换的，具体的理解在下面的方法介绍中。

成员变量解析

	  private volatile String name;				// 线程名称
	  private int  priority;					// 线程优先级
	  private boolean     daemon = false; 		// 是否是守护线程
	  private Runnable target; 					// 执行的任务
	  private ThreadGroup group;				// 所在的线程组
	  private ClassLoader contextClassLoader;		// 上下文类加载器
	  private AccessControlContext inheritedAccessControlContext;
	  ThreadLocal.ThreadLocalMap threadLocals = null;			// 内部挂载的map容器
	  ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;   // 内部挂载的父子线程传递的map容器
	  private volatile int threadStatus = 0;		// 用于判断线程是否启动
	  private volatile Interruptible blocker;		
	  private long tid;
	  private volatile Interruptible blocker;
	  private final Object blockerLock = new Object();   // 线程内部的锁

构造器

Thread线程的创建共有九种方式：

一、public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
二、public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}
三、Thread(Runnable target, AccessControlContext acc) {
    init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
}
四、public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}
五、public Thread(String name) {
    init(null, null, name, 0);
}
六、public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}
七、public Thread(Runnable target, String name) {
    init(null, target, 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);
}

从上可以看出，不论有多少种创建方式，这都基于其调用的init初始化方法。所以，了解了init初始化方法，对线程的创建就知道大概了。

init（）线程初始化

/**
*  在注入参数中，分别是当前线程组、执行任务目标、线程名字、程序栈大小、类加载器、
*/
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) {
        /* Determine if it's an applet or not */
        /* If there is a security manager, ask the security manager
           what to do. */
        if (security != null) {
            g = security.getThreadGroup();
        }

        /* If the security doesn't have a strong opinion of the matter
           use the parent thread group. */
        if (g == null) {
            g = parent.getThreadGroup();		// 将新线程归入到父线程的组
        }
    }

    g.checkAccess();

    /*
     * Do we have the required permissions?
     */
    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();
    this.target = target;
    setPriority(priority);
    
    // 下方表示：线程中的inheritableThreadLocals指向的集合可以在父子线程之间传递。
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    
    // 指定栈大小
    this.stackSize = stackSize;

   // 获取线程唯一编号
    tid = nextThreadID();
}

如果对线程的初始化很懵，虽然我分析得也不是很深入，但是我还是得画个图出来大概解释一下，为什么会这样初始化。

1. 首先是线程的成员变量定义了线程需要的参数有哪些，所以在初始化方法中才需要这些重要的参数注入。
2. 线程的编组方法：
   
   如上图所示，每一个线程肯定都在某一个线程组中，对于新创建的线程而言，比如S1xianc线程，其父线程是P，如果没有指定线程组，那么它也会在父线程P所在的组内。如果指定了线程组，如S3线程，虽然P也是它的父亲，但它可以在其他组内。

还有一点，在线程中没有明确的“父子线程”这个结构，这个描述只是基于线程初始化中的如下代码：

	Thread parent = currentThread();			// 指定创建线程为父线程
	...
	 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();

它说明每个线程都是被赋予了创建者线程的一些结构和数据，但是他们并没有继承关系。
每一个线程组都与它的父组关联，是一个典型的树状结构。
基于这样的线程父子继承关系，每一个线程也与它的直接父线程关联，ThreadLocal的设计，实现了线程内的变量传递，但是无法实现线程之间的变量传递，因此基于父子线程关系，设计出了inheritableThreadLocals 这个变量用来满足父子线程间的变量传递，这个传递在线程初始化时进行。
但是具体是只传递了Map结构，还是结构及数据都传递了呢？

根据初始化代码继续向下：

  this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

这里调用了ThreadLocalMap的构造器

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}

private ThreadLocalMap(ThreadLocalMap parentMap) {

        Entry[] parentTable = parentMap.table;			// 传递父对象的结构
        int len = parentTable.length;
        setThreshold(len);
        table = new Entry[len];

        for (int j = 0; j < len; j++) {					// 遍历父对象的每个结点
            Entry e = parentTable[j];
            if (e != null) {
                @SuppressWarnings("unchecked")
                ThreadLocal