Java读源码之Thread

前言

JDK版本：1.8

阅读了Object的源码，wait和notify方法与线程联系紧密，而且多线程已经是必备知识，那保持习惯，就从多线程的源头Thread类开始读起吧。由于该类比较长，只读重要部分

源码

类声明和重要属性

package java.lang;

public class Thread implements Runnable {

    private volatile String name;
    // 优先级
    private int            priority;
    //是否后台
    private boolean     daemon = false;
    /* JVM state */
    private boolean     stillborn = false;
    // 要跑的任务
    private Runnable target;
    // 线程组
    private ThreadGroup group;
    // 上下文加载器
    private ClassLoader contextClassLoader;
    // 权限控制上下文
    private AccessControlContext inheritedAccessControlContext;
    // 线程默认名字“Thread-{{ threadInitNumber }}”
    private static int threadInitNumber;
    // 线程本地局部变量，每个线程拥有各自独立的副本
    ThreadLocal.ThreadLocalMap threadLocals = null;
    // 有时候线程本地局部变量需要被子线程继承
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    // 线程初始化时申请的JVM栈大小
    private long stackSize;
    // 线程ID
    private long tid;
    // 线程init之后的ID
    private static long threadSeqNumber;
    // 0就是线程还处于NEW状态，没start
    private volatile int threadStatus = 0;
    // 给LockSupport.park用的需要竞争的对象
    volatile Object parkBlocker;
    // 给中断用的需要竞争的对象
    private volatile Interruptible blocker;
    // 线程最小优先级
    public final static int MIN_PRIORITY = 1;
    // 线程默认优先级
    public final static int NORM_PRIORITY = 5;
    // 线程最大优先级
    public final static int MAX_PRIORITY = 10;

Java线程有几种状态？

// Thread类中的枚举
public enum State {
    // 线程刚创建出来还没start
    NEW,
    // 线程在JVM中运行了，需要去竞争资源，例如CPU
    RUNNABLE,
    // 线程等待获取对象监视器锁，损被别人拿着就阻塞
    BLOCKED,
    // 线程进入等待池了，等待觉醒
    WAITING,
    // 指定了超时时间
    TIMED_WAITING,
    // 线程终止
    TERMINATED;
}

下面这个图可以帮助理解Java线程的生命周期，这个图要会画！面试中被问到，当时画的很不专业，难受！

创建

那么线程如何进入初始New状态呢？让我们来看看构造，头皮发麻，怎么有七八个构造，这里只贴了一个

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

还好都是调用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) {
        // 通过security获取线程组，其实就是拿的当前线程的组
        if (security != null) {
            g = security.getThreadGroup();
        }

        // 获取当前线程的组，这下确保肯定有线程组了
        if (g == null) {
            g = parent.getThreadGroup();
        }
    }

    // check一下组是否存在和是否有线程组修改权限
    g.checkAccess();

    // 子类执行权限检查，子类不能重写一些不是final的敏感方法
    if (security != null) {
        if (isCCLOverridden(getClass())) {
            security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
        }
    }
	// 组里未启动的线程数加1，长时间不启动就会被回收
    g.addUnstarted();
	// 线程的组，是否后台，优先级，初始全和当前线程一样
    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    if (security == null || isCCLOverridden(parent.getClass()))
        // 子类重写check没过或者就没有security，这里要check下是不是连装载的权限都没有
        this.contextClassLoader = parent.getContextClassLoader();
    else
        this.contextClassLoader = parent.contextClassLoader;
    // 访问控制上下文初始化
    this.inheritedAccessControlContext =
        acc != null ? acc : AccessController.getContext();
    // 任务初始化
    this.target = target;
    // 设置权限
    setPriority(priority);
    // 如果有需要继承的ThreadLocal局部变量就copy一下
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    // 初始化JVM中待创建线程的栈大小
    this.stackSize = stackSize;

    // threadSeqNumber线程号加1
    tid = nextThreadID();
}

运行

现在线程已经是NEW状态了，我们还需要调用start方法，让线程进入RUNNABLE状态，真正在JVM中快乐的跑起来，当获得了执行任务所需要的资源后，JVM便会调用target（Runnable）的run方法。

注意：我们永远不要对同一个线程对象执行两次start方法

public synchronized void start() {
    // 0就是NEW状态
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    // 把当前线程加到线程组的线程数组中，然后nthreads线程数加1，nUnstartedThreads没起的线程数减1
    group.add(this);

    boolean started = false;
    // 请求资源
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
    // 起失败啦，把当前线程从线程组的线程数组中删除，然后nthreads减1，nUnstartedThreads加1
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            // start0出问题会自己打印堆栈信息
        }
    }
}

private native void start0();

终止

现在我们的线程已经到RUNNABLE状态了，一切顺利的话任务执行完成，自动进入TERMINATED状态，天有不测风云，我们还会再各个状态因为异常到达TERMINATED状态。

Thread类为我们提供了interrupt方法，可以设置中断标志位，设置了中断之后不一定有影响，还需要满足一定的条件才能发挥作用：

• RUNNABLE状态下
  • 默认什么都不会发生，需要代码中循环检查 中断标志位
• WAITING/TIMED_WAITING状态下
  • 这两个状态下，会从对象等待池中出来，等拿到监视器锁会抛出InterruptedException异常，然后中断标志位被清空。
• BLOCKED状态下
  • 如果线程在等待锁，对线程对象调用interrupt()只是会设置线程的中断标志位，线程依然会处于BLOCKED状态
• NEW/TERMINATE状态下
  • 啥也不发生

// 设置别的线程中断
public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();
	// 拿一个可中断对象Interruptible的锁
    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // 设置中断标志位
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

// 获取当前线程中断标志位，然后重置中断标志位
public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

// 检查线程中断标志位
public boolean isInterrupted() {
    return isInterrupted(false);
}

等待

主线已经做完了，下面来看下支线任务，同样重要哦。从线程状态图看到，RUNNABLE状态可以变成BLOCKED，WAITING或TIMED_WAITING。

其中BLOCKED主要是同步方法竞争锁等同步资源造成的，而TIMED_WAITING主要是加了超时时间，其他和WAITING的内容差不多，唯一多了一个sleep方法。

sleep

果不其然，sleep方法和Object.wait方法如出一辙，都是调用本地方法，提供毫秒和纳秒两种级别的控制，唯一区别就是，sleep不会放弃任何占用的监视器锁

public static native void sleep(long millis) throws InterruptedException;

// 纳秒级别控制
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);
}

join

join方法会让线程进入WAITING，等待另一个线程的终止，整个方法和Object.wait方法也是很像，而且实现中也用到了wait，既然用到了wait方法，自然也会释放调用对象的监视器锁

public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        // 判断调用join的线程是否活着，这里的活着是指RUNNABLE,BLOCKED,WAITING,TIMED_WAITING这四种状态，如果活着就一直等着，wait(0)意味着无限等
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

// 纳秒级别控制
public final synchronized void join(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++;
    }

    join(millis);
}

public final void join() throws InterruptedException {
    join(0);
}

其他方法

yield

告诉操作系统的调度器：我的cpu可以先让给其他线程,但是我占有的同步资源不让。

注意，调度器可以不理会这个信息。这个方法几乎没用，调试并发bug可能能派上用场

public static native void yield();

setPriority

有些场景是需要根据线程的优先级来调度的，优先级越大越先执行，最大10，默认5，最小1

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        // 如果设置的优先级，比线程所属线程组中优先级的最大值还大，我们需要更新最大值
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        // 本地方法
        setPriority0(priority = newPriority);
    }
}

弃用方法

有些熟悉的方法已经被弃用了，我们要避免使用

@Deprecated
public final void stop()
@Deprecated
public final synchronized void stop(Throwable obj)
@Deprecated
public void destroy()
@Deprecated
public final void suspend()
@Deprecated
public final void resume()
@Deprecated
public native int countStackFrames()

实践

interrupt()

public class ThreadInterruptTest {

    /**
     * 如果我们同时调用了notify和interrupt方法，程序有可能正常执行结束，有可能抛出异常结束,
     * 原因是不管是因为notify还是interrupt,线程离开了等待池，都需要去竞争锁,
     * 如果interrupt调用瞬间拿到锁，notify还没有调用，就抛中断异常
     * 如果是interrupt调用瞬间拿不到锁，此时中断标志位被重置，然后notify把线程拉到正常轨道，就继续执行不抛中断异常
     */
    private static void testInterrupt() {
        Object object = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (object) {
                try {
                    object.wait();
                    System.out.println("我还活着！");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }

            }

        });

        thread1.start();

        new Thread(() -> {
            // 只为了演示，实际很少用到这些方法，而且我们在执行中断的同步代码块中最好不要做别的事情，例如这里的notify
            synchronized (object) {
                thread1.interrupt();
                object.notify();
            }
        }).start();
    }

    public static void main(String[] args) {
        for (int i = 0; i <5 ; i++) {
            ThreadInterruptTest.testInterrupt();
        }

    }
}
/**
 * 输出：
 * 我还活着！
 * java.lang.InterruptedException
 * 	at java.lang.Object.wait(Native Method)
 * 	at java.lang.Object.wait(Object.java:502)
 * 	at study.ThreadInterruptTest.lambda$testInterrupt$0(ThreadInterruptTest.java:15)
 * 	at java.lang.Thread.run(Thread.java:748)
 * java.lang.InterruptedException
 * 	at java.lang.Object.wait(Native Method)
 * 	at java.lang.Object.wait(Object.java:502)
 * 	at study.ThreadInterruptTest.lambda$testInterrupt$0(ThreadInterruptTest.java:15)
 * 	at java.lang.Thread.run(Thread.java:748)
 * 我还活着！
 * java.lang.InterruptedException
 * 	at java.lang.Object.wait(Native Method)
 * 	at java.lang.Object.wait(Object.java:502)
 * 	at study.ThreadInterruptTest.lambda$testInterrupt$0(ThreadInterruptTest.java:15)
 * 	at java.lang.Thread.run(Thread.java:748)
 *
 */

join()

public class ThreadJoinTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            System.out.println("你好");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("你更好！");
        });

        thread1.start();

        new Thread(() -> {
            System.out.println("你也好");
            try {
                thread1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("你最好！！");
        }).start();
    }

    /**
     * 输出：
     * 你好
     * 你也好
     * 你更好！
     * 你最好！！
     */
}