本来想看 ThreadLocal 的源码的，但发现其中最重要的 get/set 方法都是操纵的 Thread 类 中的 threadLocals 变量 (java.lang.ThreadLocal.ThreadLocalMap)，索性先来看一下 Thread 的源码吧，可以留意一下其中与 ThreadLocal 相关的属性，这样下次阅读 ThreadLocal 的核心 API 时，就能够轻易理解其原理咯。不多 BB，直接上硬菜。

    实现多线程从本质上都是由 Thread 类 来完成的，其源码量很多，本次只看一些常见且重要的部分，源码和解析如下。

    1. public class Thread implements Runnable {
    2.     /** 这里只看一些 常见的参数 */
    3.     /** 线程名 */
    4.     private volatile char name[];
    5.     /** 优先级 */
    6.     private int priority;
    7.     /** 是否为守护线程 */
    8.     private boolean daemon;
    9.     /** 线程要执行的目标任务 */
    10.     private Runnable target;
    11.     /** 所属线程组 */
    12.     private ThreadGroup group;
    13.     /** 类加载器 */
    14.     private ClassLoader contextClassLoader;
    15.     /**
    16.      * ThreadLocal 能为线程设置线程私有变量 就是通过下面这个threadLocals变量完成的，
    17.      * ThreadLocal的get/set方法就是通过操作 各个线程的 threadLocals 变量实现的。
    18.      * 1、线程A持有一个 ThreadLocalMap 变量；
    19.      * 2、线程A调用一个类的 ThreadLocal变量 tlA 的 get/set方法；
    20.      * 3、tlA（ThreadLocal）的 get/set方法 获取当前线程A，调用 线程A 的 ThreadLocalMap变量 的get/put方法；
    21.      * 4、其它线程 调用 tlA（ThreadLocal）的 get/set方法 同理。
    22.      */
    23.     ThreadLocal.ThreadLocalMap threadLocals;
    24.     ThreadLocal.ThreadLocalMap inheritableThreadLocals;
    25.     /** 线程栈的大小 */
    26.     private long stackSize;
    27.     /**
    28.      * Thread类定义了6个线程状态：New、Runnable、Blocked、Waiting、TimedWaiting、Terminated(终止)
    29.      * 实际上还会把 Runnable 再细分为 就绪(未抢到时间片) 和 运行中(抢到时间片)
    30.      */
    31.     private volatile int threadStatus;
    32.     /** 最小优先级 */
    33.     public static final int MIN_PRIORITY = 1;
    34.     /** 中等优先级 */
    35.     public static final int NORM_PRIORITY = 5;
    36.     /** 最大优先级 */
    37.     public static final int MAX_PRIORITY = 10;
    39.     /**
    40.      * 内部枚举类，用来描述线程状态，状态值有：
    41.      * NEW：          新建，还未调用start()方法；
    42.      * RUNNABLE：     运行，在java多线程模型中，就绪和运行都是运行状态；
    43.      * BLOCKED：      阻塞；
    44.      * WAITING：      等待，需要其他的线程来唤醒；
    45.      * TIMED_WAITING：超时等待，可以在指定的时间内自动醒来，如 sleep()方法；
    46.      * TERMINATED：   终止，线程执行完毕。
    47.      */
    48.     public static final class State extends Enum {
    50.         public static final State NEW;
    51.         public static final State RUNNABLE;
    52.         public static final State BLOCKED;
    53.         public static final State WAITING;
    54.         public static final State TIMED_WAITING;
    55.         public static final State TERMINATED;
    56.         private static final State VALUES[];
    58.         static {
    59.             NEW = new State("NEW", 0);
    60.             RUNNABLE = new State("RUNNABLE", 1);
    61.             BLOCKED = new State("BLOCKED", 2);
    62.             WAITING = new State("WAITING", 3);
    63.             TIMED_WAITING = new State("TIMED_WAITING", 4);
    64.             TERMINATED = new State("TERMINATED", 5);
    65.             VALUES = (new State[] { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED });
    66.         }
    68.         private State(String s, int i) {
    69.             super(s, i);
    70.         }
    71.     }
    73.     /**
    74.      * 一系列 构造方法 ------------------------------------------------------
    75.      * 可以看出来，其中都调用了init()方法，这也是一个约定俗成的规矩， 即，如果要在 new 时进行一些初始化操作，
    76.      * 那么请将初始化操作单独写在 init()方法中，然后在构造函数中调用该 init()方法
    77.      */
    78.     public Thread() {
    79.         daemon = false;
    80.         stillborn = false;
    81.         threadLocals = null;
    82.         inheritableThreadLocals = null;
    83.         threadStatus = 0;
    84.         blockerLock = new Object();
    85.         init(null, null, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    86.     }
    88.     public Thread(Runnable runnable) {
    89.         daemon = false;
    90.         stillborn = false;
    91.         threadLocals = null;
    92.         inheritableThreadLocals = null;
    93.         threadStatus = 0;
    94.         blockerLock = new Object();
    95.         init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    96.     }
    98.     Thread(Runnable runnable, AccessControlContext accesscontrolcontext) {
    99.         daemon = false;
    100.         stillborn = false;
    101.         threadLocals = null;
    102.         inheritableThreadLocals = null;
    103.         threadStatus = 0;
    104.         blockerLock = new Object();
    105.         init(null, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L,
    106.                 accesscontrolcontext);
    107.     }
    109.     public Thread(ThreadGroup threadgroup, Runnable runnable) {
    110.         daemon = false;
    111.         stillborn = false;
    112.         threadLocals = null;
    113.         inheritableThreadLocals = null;
    114.         threadStatus = 0;
    115.         blockerLock = new Object();
    116.         init(threadgroup, runnable, (new StringBuilder()).append("Thread-").append(nextThreadNum()).toString(), 0L);
    117.     }
    119.     public Thread(String s) {
    120.         daemon = false;
    121.         stillborn = false;
    122.         threadLocals = null;
    123.         inheritableThreadLocals = null;
    124.         threadStatus = 0;
    125.         blockerLock = new Object();
    126.         init(null, null, s, 0L);
    127.     }
    129.     public Thread(ThreadGroup threadgroup, String s) {
    130.         daemon = false;
    131.         stillborn = false;
    132.         threadLocals = null;
    133.         inheritableThreadLocals = null;
    134.         threadStatus = 0;
    135.         blockerLock = new Object();
    136.         init(threadgroup, null, s, 0L);
    137.     }
    139.     public Thread(Runnable runnable, String s) {
    140.         daemon = false;
    141.         stillborn = false;
    142.         threadLocals = null;
    143.         inheritableThreadLocals = null;
    144.         threadStatus = 0;
    145.         blockerLock = new Object();
    146.         init(null, runnable, s, 0L);
    147.     }
    149.     public Thread(ThreadGroup threadgroup, Runnable runnable, String s) {
    150.         daemon = false;
    151.         stillborn = false;
    152.         threadLocals = null;
    153.         inheritableThreadLocals = null;
    154.         threadStatus = 0;
    155.         blockerLock = new Object();
    156.         init(threadgroup, runnable, s, 0L);
    157.     }
    159.     public Thread(ThreadGroup threadgroup, Runnable runnable, String s, long l) {
    160.         daemon = false;
    161.         stillborn = false;
    162.         threadLocals = null;
    163.         inheritableThreadLocals = null;
    164.         threadStatus = 0;
    165.         blockerLock = new Object();
    166.         init(threadgroup, runnable, s, l);
    167.     }
    169.     private void init(ThreadGroup threadgroup, Runnable runnable, String s, long l) {
    170.         init(threadgroup, runnable, s, l, null);
    171.     }
    173.     /**
    174.      * 初始化线程
    175.      */
    176.     private void init(ThreadGroup threadgroup, Runnable runnable, String name, long l,
    177.             AccessControlContext accesscontrolcontext) {
    179.         // 参数校验，线程name不能为null
    180.         if (name == null)
    181.             throw new NullPointerException("name cannot be null");
    182.         this.name = name.toCharArray();
    183.         // 当前线程就是该线程的父线程
    184.         Thread parent = currentThread();
    185.         SecurityManager securitymanager = System.getSecurityManager();
    186.         if (threadgroup == null) {
    187.             if (securitymanager != null)
    188.                 threadgroup = securitymanager.getThreadGroup();
    189.             if (threadgroup == null)
    190.                 threadgroup = parent.getThreadGroup();
    191.         }
    192.         threadgroup.checkAccess();
    193.         if (securitymanager != null && isCCLOverridden(getClass()))
    194.             securitymanager.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
    195.         threadgroup.addUnstarted();
    196.         // 守护线程、优先级等设置为父线程的对应属性
    197.         group = threadgroup;
    198.         daemon = parent.isDaemon();
    199.         priority = parent.getPriority();
    200.         if (securitymanager == null || isCCLOverridden(parent.getClass()))
    201.             contextClassLoader = parent.getContextClassLoader();
    202.         else
    203.             contextClassLoader = parent.contextClassLoader;
    204.         inheritedAccessControlContext = accesscontrolcontext == null ? AccessController.getContext()
    205.                 : accesscontrolcontext;
    206.         target = runnable;
    207.         setPriority(priority);
    208.         if (parent.inheritableThreadLocals != null)
    209.             // 创建线程共享变量副本
    210.             inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    211.         stackSize = l;
    212.         // 分配线程id
    213.         tid = nextThreadID();
    214.     }
    216.     public synchronized void start() {
    217.         //假若当前线程初始化还未做好，不能start，0->NEW状态
    218.         if (threadStatus != 0)
    219.             throw new IllegalThreadStateException();
    221.         //通知group该线程即将启动，group的未启动线程数量减1
    222.         group.add(this);
    224.         boolean started = false;
    225.         try {
    226.             // 调用native的start0()方法 启动线程，启动后执行run()方法
    227.             start0();
    228.             started = true;
    229.         } finally {
    230.             try {
    231.                 //启动不成功，group设置当前线程启动失败
    232.                 if (!started) {
    233.                     group.threadStartFailed(this);
    234.                 }
    235.             } catch (Throwable ignore) {
    237.             }
    238.         }
    239.     }
    241.     private native void start0();
    243.     public void run() {
    244.         if (target != null)
    245.             target.run();
    246.     }
    248.     /**
    249.      * 请求终止线程。interrupt不会真正停止一个线程，它仅仅是给这个线程发了一个信号，
    250.      * 告诉它要结束了，具体要中断还是继续运行，将由被通知的线程自己处理
    251.      */
    252.     public void interrupt() {
    253.         if (this != Thread.currentThread())
    254.             checkAccess();
    255.         synchronized (blockerLock) {
    256.             Interruptible b = blocker;
    257.             if (b != null) {
    258.                 interrupt0();
    259.                 b.interrupt(this);
    260.                 return;
    261.             }
    262.         }
    263.         interrupt0();
    264.     }
    266.     private native void interrupt0();
    268.     /**
    269.      * 线程main 调用了线程A的join方法，则 线程main 会被阻塞，直到线程A执行完毕
    270.      */
    271.     public final void join() throws InterruptedException {
    272.         join(0);
    273.     }
    275.     /**
    276.      * 实际上是利用 wait/notify机制 来实现的
    277.      */
    278.     public final synchronized void join(long millis) throws InterruptedException {
    279.         long base = System.currentTimeMillis();
    280.         long now = 0;
    282.         if (millis < 0) {
    283.             throw new IllegalArgumentException("timeout value is negative");
    284.         }
    285.         // millis 为 0，所以走这个分支
    286.         if (millis == 0) {
    287.             // 当前线程是否还在运行，还在运行 则main线程 进入等待状态，直到 A线程运行完毕，将其唤醒
    288.             while (isAlive()) {
    289.                 wait(0);
    290.             }
    291.         } else {
    292.             while (isAlive()) {
    293.                 long delay = millis - now;
    294.                 if (delay <= 0) {
    295.                     break;
    296.                 }
    297.                 wait(delay);
    298.                 now = System.currentTimeMillis() - base;
    299.             }
    300.         }
    301.     }
    303.     /**
    304.      * 线程睡眠指定的时间，释放CPU资源，但不释放锁
    305.      */
    306.     public static native void sleep(long millis) throws InterruptedException;
    308.     /**
    309.      * 线程是否还在运行
    310.      */
    311.     public final native boolean isAlive();
    312. }

    之前一直对线程状态 及 状态切换的概念模糊不清，现在通过源码中对线程状态的定义，我们可以画张图来重新回顾一下，以使我们对其有更加深刻的理解。

    avatar