天天看點
傳回

【高并發】朋友去面試竟然栽在了Thread類的源碼上

大家好，我是冰河~~

前言

最近和一個朋友聊天，他跟我說起了他去XXX公司面試的情況，面試官的一個問題把他打懵了！竟然問他：你經常使用Thread建立線程，那你看過Thread類的源碼嗎？我這個朋友自然是沒看過Thread類的源碼，然後，就沒有然後了！！！

是以，我們學習技術不僅需要知其然，更需要知其是以然，今天，我們就一起來簡單看看Thread類的源碼。

注意：本文是基于JDK 1.8來進行分析的。

Thread類的繼承關系

我們可以使用下圖來表示Thread類的繼承關系。

【高并發】朋友去面試竟然栽在了Thread類的源碼上

由上圖我們可以看出，Thread類實作了Runnable接口，而Runnable在JDK 1.8中被@FunctionalInterface注解标記為函數式接口，Runnable接口在JDK 1.8中的源代碼如下所示。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runnable接口的源碼比較簡單，隻是提供了一個run()方法，這裡就不再贅述了。

接下來，我們再來看看@FunctionalInterface注解的源碼，如下所示。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

可以看到，@FunctionalInterface注解聲明标記在Java類上，并在程式運作時生效。

Thread類的源碼剖析

Thread類定義

Thread在java.lang包下，Thread類的定義如下所示。

public class Thread implements Runnable {

加載本地資源

打開Thread類後，首先，我們會看到在Thread類的最開始部分，定義了一個靜态本地方法registerNatives()，這個方法主要用來注冊一些本地系統的資源。并在靜态代碼塊中調用這個本地方法，如下所示。

//定義registerNatives()本地方法注冊系統資源
private static native void registerNatives();
static {
    //在靜态代碼塊中調用注冊本地系統資源的方法
    registerNatives();
}

Thread中的成員變量

Thread類中的成員變量如下所示。

//目前線程的名稱
private volatile String name;
//線程的優先級
private int            priority;
private Thread         threadQ;
private long           eetop;
//目前線程是否是單步線程
private boolean     single_step;
//目前線程是否在背景運作
private boolean     daemon = false;
//Java虛拟機的狀态
private boolean     stillborn = false;
//真正線上程中執行的任務
private Runnable target;
//目前線程所在的線程組
private ThreadGroup group;
//目前線程的類加載器
private ClassLoader contextClassLoader;
//通路控制上下文
private AccessControlContext inheritedAccessControlContext;
//為匿名線程生成名稱的編号
private static int threadInitNumber;
//與此線程相關的ThreadLocal,這個Map維護的是ThreadLocal類
ThreadLocal.ThreadLocalMap threadLocals = null;
//與此線程相關的ThreadLocal
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
//目前線程請求的堆棧大小，如果未指定堆棧大小，則會交給JVM來處理
private long stackSize;
//線程終止後存在的JVM私有狀态
private long nativeParkEventPointer;
//線程的id
private long tid;
//用于生成線程id
private static long threadSeqNumber;
//目前線程的狀态，初始化為0，代表目前線程還未啟動
private volatile int threadStatus = 0;
//由（私有）java.util.concurrent.locks.LockSupport.setBlocker設定
//使用java.util.concurrent.locks.LockSupport.getBlocker通路
volatile Object parkBlocker;
//Interruptible接口中定義了interrupt方法，用來中斷指定的線程
private volatile Interruptible blocker;
//目前線程的内部鎖
private final Object blockerLock = new Object();
//線程擁有的最小優先級
public final static int MIN_PRIORITY = 1;
//線程擁有的預設優先級
public final static int NORM_PRIORITY = 5;
//線程擁有的最大優先級
public final static int MAX_PRIORITY = 10;

從Thread類的成員變量，我們可以看出，Thread類本質上不是一個任務，它是一個實實在在的線程對象，在Thread類中擁有一個Runnable類型的成員變量target，而這個target成員變量就是需要在Thread線程對象中執行的任務。

線程的狀态定義

在Thread類的内部，定義了一個枚舉State，如下所示。

public enum State {
   //初始化狀态
    NEW,
   //可運作狀态，此時的可運作包括運作中的狀态和就緒狀态
    RUNNABLE,
   //線程阻塞狀态
    BLOCKED,
   //等待狀态
    WAITING,
    //逾時等待狀态
    TIMED_WAITING,
    //線程終止狀态
    TERMINATED;
}

這個枚舉類中的狀态就代表了線程生命周期的各狀态。我們可以使用下圖來表示線程各個狀态之間的轉化關系。

【高并發】朋友去面試竟然栽在了Thread類的源碼上
  • NEW：初始狀态，線程被建構，但是還沒有調用start()方法。
  • RUNNABLE：可運作狀态，可運作狀态可以包括：運作中狀态和就緒狀态。
  • BLOCKED：阻塞狀态，處于這個狀态的線程需要等待其他線程釋放鎖或者等待進入synchronized。
  • WAITING：表示等待狀态，處于該狀态的線程需要等待其他線程對其進行通知或中斷等操作，進而進入下一個狀态。
  • TIME_WAITING：逾時等待狀态。可以在一定的時間自行傳回。
  • TERMINATED：終止狀态，目前線程執行完畢。

Thread類的構造方法

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);
}

其中，我們最經常使用的就是如下幾個構造方法了。

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target) {
    init(null, 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);
}

通過Thread類的源碼，我們可以看出，Thread類在進行初始化的時候，都是調用的init()方法，接下來，我們看看init()方法是個啥。

init()方法 

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) {
        //擷取的系統安全管理器不為空
        if (security != null) {
            //從系統安全管理器中擷取一個線程分組
            g = security.getThreadGroup();
        }
        //線程分組為空，則從父線程擷取
        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();
    this.target = target;
    setPriority(priority);
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    //設定線程id
    tid = nextThreadID();
}

Thread類中的構造方法是被建立Thread線程的線程調用的，此時，調用Thread的構造方法建立線程的線程就是父線程，在init()方法中，新建立的Thread線程會繼承父線程的部分屬性。

run()方法

既然Thread類實作了Runnable接口，則Thread類就需要實作Runnable接口的run()方法，如下所示。

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

可以看到，Thread類中的run()方法實作非常簡單，隻是調用了Runnable對象的run()方法。是以，真正的任務是運作在run()方法中的。另外，需要注意的是：直接調用Runnable接口的run()方法不會建立新線程來執行任務，如果需要建立新線程執行任務，則需要調用Thread類的start()方法。

start()方法 

public synchronized void start() {
   //線程不是初始化狀态，則直接抛出異常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    //添加目前啟動的線程到線程組
    group.add(this);
    //标記線程是否已經啟動
    boolean started = false;
    try {
        //調用本地方法啟動線程
        start0();
        //将線程是否啟動标記為true
        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 */
        }
    }
}

private native void start0();

從start()方法的源代碼，我們可以看出：start()方法使用synchronized關鍵字修飾，說明start()方法是同步的，它會在啟動線程前檢查線程的狀态，如果不是初始化狀态，則直接抛出異常。是以，一個線程隻能啟動一次，多次啟動是會抛出異常的。

這裡，也是面試的一個坑：面試官：【問題一】能不能多次調用Thread類的start()方法來啟動線程嗎？【問題二】多次調用Thread線程的start()方法會發生什麼？【問題三】為什麼會抛出異常？

調用start()方法後，新建立的線程就會處于就緒狀态（如果沒有配置設定到CPU執行），當有空閑的CPU時，這個線程就會被配置設定CPU來執行，此時線程的狀态為運作狀态，JVM會調用線程的run()方法執行任務。

sleep()方法

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);
}

sleep()方法會讓目前線程休眠一定的時間，這個時間通常是毫秒值，這裡需要注意的是：調用sleep()方法使線程休眠後，線程不會釋放相應的鎖。

join()方法

join()方法會一直等待線程逾時或者終止，代碼如下所示。

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) {
        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);
}

join()方法的使用場景往往是啟動線程執行任務的線程，調用執行線程的join()方法，等待執行線程執行任務，直到逾時或者執行線程終止。

interrupt()方法

interrupt()方法是中斷目前線程的方法，它通過設定線程的中斷标志位來中斷目前線程。此時，如果為線程設定了中斷标志位，可能會抛出InteruptedExeption異常，同時，會清除目前線程的中斷狀态。這種方式中斷線程比較安全，它能使正在執行的任務執行能夠繼續執行完畢，而不像stop()方法那樣強制線程關閉。代碼如下所示。

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();           // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    //調用本地方法中斷線程
    interrupt0();
}
private native void interrupt0();

總結

作為技術人員，要知其然，更要知其是以然，我那個朋友技術本身不錯，各種架構拿來就用，基本沒看過常用的架構源碼和JDK中常用的API，屬于那種CRUD型程式員，這次面試就栽在了一個簡單的Thread類上，是以，大家在學會使用的時候，一定要了解下底層的實作才好啊！

推薦閱讀

《

實踐出真知：全網最強秒殺系統架構解密，不是所有的秒殺都是秒殺！！

》

注意：線程的執行順序與你想的并不一樣！！ 深入解析Callable接口 兩種異步模型與深度解析Future接口！ 解密SimpleDateFormat類的線程安全問題和六種解決方案！ 不得不說的線程池與ThreadPoolExecutor類淺析 深度解析線程池中那些重要的頂層接口和抽象類 從源碼角度分析建立線程池究竟有哪些方式 通過源碼深度解析ThreadPoolExecutor類是如何保證線程池正确運作的 通過ThreadPoolExecutor類的源碼深度解析線程池執行任務的核心流程 通過源碼深度分析線程池中Worker線程的執行流程 從源碼角度深度解析線程池是如何實作優雅退出的 ScheduledThreadPoolExecutor與Timer的差別和簡單示例 深度解析ScheduledThreadPoolExecutor類的源代碼 由InterruptedException異常引發的思考 淺談AQS中的CountDownLatch、Semaphore與CyclicBarrier 淺談AQS中的ReentrantLock、ReentrantReadWriteLock、StampedLock與Condition

好了，今天就到這兒吧，我是冰河，我們下期見~~

安全 java 程式員 api java退出程式 thread源碼分析 并發thread 安全java thread場景
上一篇: 阿裡雲飛天加速計劃使用體驗
下一篇: 關于ESC的初次使用感受

繼續閱讀