【高併發】一個工做了7年的朋友去面試居然被Thread類虐的體無完膚
前言
最近和一個工做了7年的朋友聊天，他跟我提及了他去XXX公司面試的狀況，面試官的一個問題把他打懵了！居然問他：你常用Thread類建立線程，那你看過Thread類的源碼嗎？Thread類建立線程的流程是什麼？如何中斷一個正在執行的線程？我這個朋友平時以爲Thread類很是簡單，天然是沒看過Thread類的源碼，而後，就沒有而後了！！！java
因此，咱們學習技術不只須要知其然，更須要知其因此然，今天，咱們就一塊兒來簡單看看Thread類的源碼。程序員
注意：本文是基於JDK 1.8來進行分析的。面試
Thread類的繼承關係
咱們可使用下圖來表示Thread類的繼承關係。安全
由上圖咱們能夠看出，Thread類實現了Runnable接口，而Runnable在JDK 1.8中被@FunctionalInterface註解標記爲函數式接口，Runnable接口在JDK 1.8中的源代碼以下所示。框架
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
Runnable接口的源碼比較簡單，只是提供了一個run()方法，這裏就再也不贅述了。ide
接下來，咱們再來看看@FunctionalInterface註解的源碼，以下所示。函數
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
能夠看到，@FunctionalInterface註解聲明標記在Java類上，並在程序運行時生效。學習
Thread類的源碼剖析
Thread類定義
Thread在java.lang包下，Thread類的定義以下所示。this
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;
}
這個枚舉類中的狀態就表明了線程生命週期的各狀態。咱們可使用下圖來表示線程各個狀態之間的轉化關係。
-
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類上，因此，你們在學會使用的時候，必定要了解下底層的實現纔好啊！
- 1. 【高併發】又一個朋友面試栽在了Thread類的stop()方法和interrupt()方法上！
- 2. 一次 MySQL 索引面試，被面試官懟的體無完膚！
- 3. 面試字節跳動，被懟的體無完膚！
- 4. 面試大廠，被懟的體無完膚！！！
- 5. 和BAT的幾個朋友一起做了份面試指南
- 6. 被360整的體無完膚，我真的怒了！
- 7. 面試了一個2年程序員，居然只會curd，網友神回覆！
- 8. 面試了一個2年程序員，居然只會curd,網友神回覆！
- 9. 面試字節跳動，我被懟得體無完膚！
- 10. 那個悲傷的朋友，去了一趟菜場竟然活過來了
- 更多相關文章...
- • Redis悲觀鎖解決高併發搶紅包的問題 - 紅包項目實戰
- • Redis樂觀鎖解決高併發搶紅包的問題 - 紅包項目實戰
- • PHP開發工具
- • 互聯網組織的未來：剖析GitHub員工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。