Thread類源碼剖析

一、引子

說來也有些汗顏，搞了幾年java，忽然發現竟然沒拜讀過java.lang.Thread類源碼，這次特地拿出來曬一曬。本文將剖析Thread類源碼（本文后面源碼全部默認JDK8），並講解一些重要的拓展點。希望對大家能有一些幫助。

本文講解主干全部出自源碼和注釋，保證了權威性。（注意：網上，某些書中很多觀點都是錯的，過時的，片面的，所以大家一定要看源碼，重要事情說N遍，看源碼！看源碼！看源碼......）

二、JVM線程狀態

在正式學習Thread類中的具體方法之前，我們先來了解一下線程有哪些狀態，這個將會有助於后面對Thread類中的方法的理解。

自JDK5開始，線程包括以下6個狀態，摘自Thread.State：

    /**
     * A thread state.  A thread can be in one of the following states:
     * <ul>
     * <li>{@link #NEW}<br>
     *     A thread that has not yet started is in this state.
     *     </li>
     * <li>{@link #RUNNABLE}<br>
     *     A thread executing in the Java virtual machine is in this state.
     *     </li>
     * <li>{@link #BLOCKED}<br>
     *     A thread that is blocked waiting for a monitor lock
     *     is in this state.
     *     </li>
     * <li>{@link #WAITING}<br>
     *     A thread that is waiting indefinitely for another thread to
     *     perform a particular action is in this state.
     *     </li>
     * <li>{@link #TIMED_WAITING}<br>
     *     A thread that is waiting for another thread to perform an action
     *     for up to a specified waiting time is in this state.
     *     </li>
     * <li>{@link #TERMINATED}<br>
     *     A thread that has exited is in this state.
     *     </li>
     * </ul>
     *
     * <p>
     * A thread can be in only one state at a given point in time.----》JVM中的線程必須只能是以上6種狀態的一種。這些狀態是JVM狀態並不能和操作系統線程狀態互相映射。 29      * These states are virtual machine states which do not reflect 30      * any operating system thread states. 31      *
     * @since   1.5
     * @see #getState
     */
    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,--->線程剛創建，還未執行（start方法） 40 
        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,--->已就緒可運行的狀態。處於此狀態的線程是正在JVM中運行的，但可能在等待操作系統級別的資源，例如CPU時間片 48 
        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,--->阻塞等待監視器鎖。處於此狀態的線程正在阻塞等待監視器鎖，以進入一個同步塊/方法，或者在執行完wait()方法后重入同步塊/方法。 57 
        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,--->等待。執行完Object.wait無超時參數操作，或者 Thread.join無超時參數操作（進入等待指定的線程執行結束），或者 LockSupport.park操作后，線程進入等待狀態。
 一般在等待狀態的線程在等待其它線程執行特殊操作，例如：等待另其它線程操作Object.notify()喚醒或者Object.notifyAll()喚醒所有。 78 
        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,--->限時等待。Thread.sleep、Object.wait帶超時時間、Thread.join帶超時時間、LockSupport.parkNanos、LockSupport.parkUntil這些操作會時線程進入限時等待。

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;--->終止，線程執行完畢。
    }

看了源碼6種狀態，很多人會迷惑怎么沒有Running狀態呢？好吧，請相信源碼，不要混淆操作系統線程狀態和java線程狀態。JVM中的線程必須只能是以上6種狀態的一種！（見上圖枚舉State 注釋中的紅色部分）。

Running其實是早期操作系統下“單線程進程”的狀態，如下圖：

 注意：上圖已年久失修，不可參考！！！！

好吧，現在是不是覺得三觀被顛覆...

最新JAVA（JVM）線程狀態轉換如下圖：

 

如上圖，可見：RUNNABLE = 正在JVM中運行的（Running）+ 可能在等待操作系統級別的資源（Ready），例如CPU時間片

　　線程創建之后，不會立即進入就緒狀態，因為線程的運行需要一些條件（比如內存資源），只有線程運行需要的所有條件滿足了，才進入就緒狀態。

　　當線程進入就緒狀態后，不代表立刻就能獲取CPU執行時間，也許此時CPU正在執行其他的事情，因此它要等待。當得到CPU執行時間之后，線程便真正進入運行狀態。

　　線程在運行狀態過程中，可能有多個原因導致當前線程不繼續運行下去，比如用戶主動讓線程睡眠（睡眠一定的時間之后再重新執行）、用戶主動讓線程等待，或者被同步塊給阻塞，此時就對應着多個狀態：time waiting（睡眠或等待一定的事件）、waiting（等待被喚醒）、blocked（阻塞）。

　　當由於突然中斷或者子任務執行完畢，線程就會被消亡。

三.Thread類中的方法

老規矩，先看源碼注釋：

/**
 * A <i>thread</i> is a thread of execution in a program. The Java  ---》一個“線程”是在在程序中執行的線程。Java虛擬機允許應用多個線程並發運行。
 * Virtual Machine allows an application to have multiple threads of
 * execution running concurrently.
 * <p>
 * Every thread has a priority. Threads with higher priority are--》每個線程都有優先級，優先級高的先執行。線程可能是守護線程或者不是。
 * executed in preference to threads with lower priority. Each thread
 * may or may not also be marked as a daemon. When code running in
 * some thread creates a new <code>Thread</code> object, the new---》線程的優先級等於創建線程的優先級，當且僅當一個線程是守護線程，創建出來的線程才是守護線程
 * thread has its priority initially set equal to the priority of the
 * creating thread, and is a daemon thread if and only if the
 * creating thread is a daemon.
 * <p>
 * When a Java Virtual Machine starts up, there is usually a single--》通常JVM啟動，有一個非守護線程作為主線程。只有當Runtime.exit被調用或者所有非守護線程死亡時（run執行完畢並返回/拋出異常）JVM會停止運行這些線程。
 * non-daemon thread (which typically calls the method named
 * <code>main</code> of some designated class). The Java Virtual
 * Machine continues to execute threads until either of the following
 * occurs:
 * <ul>
 * <li>The <code>exit</code> method of class <code>Runtime</code> has been
 *     called and the security manager has permitted the exit operation
 *     to take place.
 * <li>All threads that are not daemon threads have died, either by
 *     returning from the call to the <code>run</code> method or by
 *     throwing an exception that propagates beyond the <code>run</code>
 *     method.
 * </ul>
 * <p>
 * There are two ways to create a new thread of execution. One is to--》兩種創建線程的方法：繼承Thread類/實現Runnable接口
 * declare a class to be a subclass of <code>Thread</code>. This
 * subclass should override the <code>run</code> method of class
 * <code>Thread</code>. An instance of the subclass can then be
 * allocated and started. For example, a thread that computes primes
 * larger than a stated value could be written as follows:
 * <hr><blockquote><pre>
 *     class PrimeThread extends Thread {
 *         long minPrime;
 *         PrimeThread(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 * </pre></blockquote><hr>
 * <p>
 * The following code would then create a thread and start it running:
 * <blockquote><pre>
 *     PrimeThread p = new PrimeThread(143);
 *     p.start();
 * </pre></blockquote>
 * <p>
 * The other way to create a thread is to declare a class that
 * implements the <code>Runnable</code> interface. That class then
 * implements the <code>run</code> method. An instance of the class can
 * then be allocated, passed as an argument when creating
 * <code>Thread</code>, and started. The same example in this other
 * style looks like the following:
 * <hr><blockquote><pre>
 *     class PrimeRun implements Runnable {
 *         long minPrime;
 *         PrimeRun(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 * </pre></blockquote><hr>
 * <p>
 * The following code would then create a thread and start it running:
 * <blockquote><pre>
 *     PrimeRun p = new PrimeRun(143);
 *     new Thread(p).start();
 * </pre></blockquote>
 * <p>
 * Every thread has a name for identification purposes. More than--》每個線程有自己的名稱用來標識自己。但可能多個線程會重名，如果啟動時沒有創建名字，會自動生成一個。
 * one thread may have the same name. If a name is not specified when
 * a thread is created, a new name is generated for it.
 * <p>
 * Unless otherwise noted, passing a {@code null} argument to a constructor
 * or method in this class will cause a {@link NullPointerException} to be
 * thrown.
 *
 * @author  unascribed  --》意思是：該代碼第一原作者不是我，但我實在也不知道是誰，就記作無名氏吧（版權意識）
 * @see     Runnable
 * @see     Runtime#exit(int)
 * @see     #run()
 * @see     #stop()
 * @since   JDK1.0
 */

 

　　Thread類實現了Runnable接口，在Thread類中，

　　關鍵屬性：

　　name是表示Thread的名字，可以通過Thread類的構造器中的參數來指定線程名字，

　　priority表示線程的優先級（最大值為10，最小值為1，默認值為5），

　　daemon表示線程是否是守護線程，如果在main線程中創建了一個守護線程，當main方法運行完畢之后，守護線程也會隨着消亡。在JVM中，垃圾收集器線程就是守護線程。

　　target表示要執行的任務。

　　group線程群組

　　關鍵方法：

　　以下是關系到線程運行狀態的幾個方法：

　　1）start

　　start()用來啟動一個線程，當調用start方法后，系統才會開啟一個新的線程來執行用戶定義的子任務，在這個過程中，會為相應的線程分配需要的資源。

　　2）run

　　run()方法是不需要用戶來調用的，當通過start方法啟動一個線程之后，當線程獲得了CPU執行時間，便進入run方法體去執行具體的任務。注意，繼承Thread類必須重寫run方法，在run方法中定義具體要執行的任務。

　　3）sleep

　　sleep方法有兩個重載版本：

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

public static void sleep(long millis, int nanos) throws InterruptedException; 

　　sleep讓線程睡眠，交出CPU，讓CPU去執行其他的任務。sleep方法不會釋放鎖，也就是說如果當前線程持有對某個對象的鎖，則即使調用sleep方法，其他線程也無法訪問這個對象。sleep方法相當於讓線程進入阻塞狀態。

　　4）yield

　　調用yield方法會讓當前線程交出CPU權限，讓CPU去執行其他的線程。它跟sleep方法類似，同樣不會釋放鎖。但是yield不能控制具體的交出CPU的時間，另外，yield方法只能讓擁有相同優先級的線程有獲取CPU執行時間的機會。

　　注意，調用yield方法並不會讓線程進入阻塞狀態，而是讓線程重回就緒狀態，它只需要等待重新獲取CPU執行時間，這一點是和sleep方法不一樣的。

　　5）join

　　join方法有三個重載版本：

join()
join(long millis)     //參數為毫秒
join(long millis,int nanoseconds)    //第一參數為毫秒，第二個參數為納秒

　　可以看出，當調用thread.join()方法后，main線程會進入等待，然后等待thread執行完之后再繼續執行。

　　實際上調用join方法是調用了Object的wait方法，這個可以通過查看源碼得知：

　　

　　wait方法會讓線程進入阻塞狀態，並且會釋放線程占有的鎖，並交出CPU執行權限。

　　6）interrupt

　　interrupt，中斷。單獨調用interrupt方法可以使得處於阻塞狀態的線程拋出一個異常，也就說，它可以用來中斷一個正處於阻塞狀態的線程；

　　7）stop

　　stop方法已經是一個廢棄的方法，它是一個不安全的方法。因為調用stop方法會直接終止run方法的調用，並且會拋出一個ThreadDeath錯誤，如果線程持有某個對象鎖的話，會完全釋放鎖，導致對象狀態不一致。所以stop方法基本是不會被用到的。

　　8）destroy

　　destroy方法也是廢棄的方法。基本不會被使用到。

四、拓展點

1.LookSupport.park()和unpark()原理

LockSupport類是Java6(JSR166-JUC)引入的一個類，提供了基本的線程同步原語。LockSupport實際上是調用了Unsafe類里的函數，歸結到Unsafe里，只有兩個函數：

掛起
public native void park(boolean isAbsolute, long time);

喚醒

public native void unpark(Thread jthread); 

unpark函數為線程提供“許可(permit)”，park函數則等待“許可”。這個有點像信號量，但是這個“許可”是不能疊加的，“許可”是一次性的。

比如線程B連續調用了三次unpark函數，當線程A調用park函數就使用掉這個“許可”，如果線程A再次調用park，則進入等待狀態。

注意，unpark函數可以先於park調用。比如線程B調用unpark函數，給線程A發了一個“許可”，那么當線程A調用park時，它發現已經有“許可”了，那么它會馬上再繼續運行。

實際上，park函數即使沒有“許可”，有時也會無理由地返回，這點等下再解析。

park/unpark模型真正解耦了線程之間的同步，線程之間不再需要一個Object或者其它變量來存儲狀態，不再需要關心對方的狀態。

我們從JDK源碼開始看，java.util.concurrent.locks.LookSupport.park(）如下：

/**
     * Disables the current thread for thread scheduling purposes unless the
     * permit is available.--->停止當前線程的調度執行一直到許可可達。
     *
     * <p>If the permit is available then it is consumed and the call
     * returns immediately; otherwise the current thread becomes disabled
     * for thread scheduling purposes and lies dormant until one of three
     * things happens:
     *--->當許可條件滿足時，當前線程會立即返回。否則會一直停止線程調度並且假死一直到下面3件事情發生：
     * <ul>
     *
     * <li>Some other thread invokes {@link #unpark unpark} with the
     * current thread as the target; or
     *--->1.其它線程調用unpark方法喚醒此線程
     * <li>Some other thread {@linkplain Thread#interrupt interrupts}
     * the current thread; or
     *--->2.其它線程中斷此線程
     * <li>The call spuriously (that is, for no reason) returns.
     * </ul>
     **--->3.此線程未知錯誤返回了
     * <p>This method does <em>not</em> report which of these caused the
     * method to return. Callers should re-check the conditions which caused
     * the thread to park in the first place. Callers may also determine,
     * for example, the interrupt status of the thread upon return.
        *----》該方法不會告知是哪個原因導致的返回。調用方需要重新校驗導致線程park的條件。比如中斷狀態。
     */
    public static void park() {
        UNSAFE.park(false, 0L);//線程調用該方法，線程將一直阻塞直到超時（這里沒有超時時間為0），或者是中斷條件出現。 
    }

 

這里我們就簡單看一下park()源碼，目錄：
openjdk-8-src-b132-03_mar_2014\openjdk\hotspot\src\share\vm\runtime\park.cpp
openjdk-8-src-b132-03_mar_2014\openjdk\hotspot\src\share\vm\runtime\park.hpp
openjdk-8-src-b132-03_mar_2014\openjdk\hotspot\src\os\linux\vm\os_linux.cpp
openjdk-8-src-b132-03_mar_2014\openjdk\hotspot\src\os\linux\vm\os_linux.hpp

park.hpp：

class Parker : public os::PlatformParker {
private:
  volatile int _counter ;
  Parker * FreeNext ;
  JavaThread * AssociatedWith ; // Current association

public:
  Parker() : PlatformParker() {
    _counter       = 0 ;
    FreeNext       = NULL ;
    AssociatedWith = NULL ;
  }
protected:
  ~Parker() { ShouldNotReachHere(); }
public:
  // For simplicity of interface with Java, all forms of park (indefinite,
  // relative, and absolute) are multiplexed into one call.
  void park(bool isAbsolute, jlong time);
  void unpark();

  // Lifecycle operators
  static Parker * Allocate (JavaThread * t) ;
  static void Release (Parker * e) ;
private:
  static Parker * volatile FreeList ;
  static volatile int ListLock ;

};

os_linux.hpp中，PlatformParker：

class PlatformParker : public CHeapObj<mtInternal> {
  protected:
    enum {
        REL_INDEX = 0,
        ABS_INDEX = 1
    };
    int _cur_index;  // which cond is in use: -1, 0, 1
    pthread_mutex_t _mutex [1] ;
    pthread_cond_t  _cond  [2] ; // one for relative times and one for abs.

  public:       // TODO-FIXME: make dtor private
    ~PlatformParker() { guarantee (0, "invariant") ; }

  public:
    PlatformParker() {
      int status;
      status = pthread_cond_init (&_cond[REL_INDEX], os::Linux::condAttr());
      assert_status(status == 0, status, "cond_init rel");
      status = pthread_cond_init (&_cond[ABS_INDEX], NULL);
      assert_status(status == 0, status, "cond_init abs");
      status = pthread_mutex_init (_mutex, NULL);
      assert_status(status == 0, status, "mutex_init");
      _cur_index = -1; // mark as unused 初始化時-1未使用
    }
};

可以看到Parker類實際上用Posix的mutex，condition來實現的。
在Parker類里的_counter字段，就是用來記錄所謂的“許可”的。

park()源碼實現，為了保證源碼的完整性，就直接在源碼上注釋原理了。

void Parker::park(bool isAbsolute, jlong time) {
  // Ideally we'd do something useful while spinning, such
  // as calling unpackTime().

  // Optional fast-path check:
  // Return immediately if a permit is available.
  // We depend on Atomic::xchg() having full barrier semantics
  // since we are doing a lock-free update to _counter.
  if (Atomic::xchg(0, &_counter) > 0) return;//先嘗試能否直接拿到“許可”，即_counter>0時，如果成功，則把_counter設置為0,並返回：

  Thread* thread = Thread::current();
  assert(thread->is_Java_thread(), "Must be JavaThread");
  JavaThread *jt = (JavaThread *)thread;

  // Optional optimization -- avoid state transitions if there's an interrupt pending.
  // Check interrupt before trying to wait
  if (Thread::is_interrupted(thread, false)) {
    return;
  }

  // Next, demultiplex/decode time arguments
  timespec absTime;
  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
    return;
  }
  if (time > 0) {
    unpackTime(&absTime, isAbsolute, time);
  }


  // Enter safepoint region
  // Beware of deadlocks such as 6317397.
  // The per-thread Parker:: mutex is a classic leaf-lock.
  // In particular a thread must never block on the Threads_lock while
  // holding the Parker:: mutex.  If safepoints are pending both the
  // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
 ThreadBlockInVM tbivm(jt);//如果不成功，則構造一個ThreadBlockInVM，

  // Don't wait if cannot get lock since interference arises from
  // unblocking.  Also. check interrupt before trying wait
  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
    return;
  }

  int status ;
  if (_counter > 0)  { // no wait needed然后檢查_counter是不是>0，如果是，則把_counter設置為0，unlock mutex並返回：
    _counter = 0;
    status = pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
    // Paranoia to ensure our locked and lock-free paths interact
    // correctly with each other and Java-level accesses.
    OrderAccess::fence();
    return;
  }

#ifdef ASSERT
  // Don't catch signals while blocked; let the running threads have the signals.
  // (This allows a debugger to break into the running thread.)
  sigset_t oldsigs;
  sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals();
  pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
#endif

  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
  jt->set_suspend_equivalent();
  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

  assert(_cur_index == -1, "invariant");
  if (time == 0) {
    _cur_index = REL_INDEX; // arbitrary choice when not timed
    status = pthread_cond_wait (&_cond[_cur_index], _mutex) ;
  } else {
    _cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;
    status = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ;
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
      pthread_cond_destroy (&_cond[_cur_index]) ;
      pthread_cond_init    (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
    }
  }
  _cur_index = -1;
  assert_status(status == 0 || status == EINTR ||
                status == ETIME || status == ETIMEDOUT,
                status, "cond_timedwait");

#ifdef ASSERT
  pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif

  _counter = 0 ;
  status = pthread_mutex_unlock(_mutex) ;
  assert_status(status == 0, status, "invariant") ;
  // Paranoia to ensure our locked and lock-free paths interact
  // correctly with each other and Java-level accesses.
  OrderAccess::fence();

  // If externally suspended while waiting, re-suspend
  if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }
}

unpark()源碼實現

void Parker::unpark() {
  int s, status ;
  status = pthread_mutex_lock(_mutex);//互斥鎖加鎖
  assert (status == 0, "invariant") ;
  s = _counter;//保存初始counter
  _counter = 1;//置1
  if (s < 1) {//如果原本為0
    // thread might be parked線程可能被掛起
    if (_cur_index != -1) {
      // thread is definitely parked
      if (WorkAroundNPTLTimedWaitHang) {
        status = pthread_cond_signal (&_cond[_cur_index]);//喚醒在park中等待的線程
        assert (status == 0, "invariant");
        status = pthread_mutex_unlock(_mutex);//釋放鎖
        assert (status == 0, "invariant");
      } else {
        status = pthread_mutex_unlock(_mutex);//釋放鎖
        assert (status == 0, "invariant");
        status = pthread_cond_signal (&_cond[_cur_index]);//喚醒在park中等待的線程
        assert (status == 0, "invariant");
      }
    } else {
      pthread_mutex_unlock(_mutex);//釋放鎖
      assert (status == 0, "invariant") ;
    }
  } else {//如果原本為1，釋放鎖
    pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
  }
}

2.Caches緩存類

Caches-->WeakClassKey-->WeakReference

/** cache of subclass security audit results */
    /* Replace with ConcurrentReferenceHashMap when/if it appears in a future
     * release */
    private static class Caches {
        /** cache of subclass security audit results */
        static final ConcurrentMap<WeakClassKey,Boolean> subclassAudits =
            new ConcurrentHashMap<>();

        /** queue for WeakReferences to audited subclasses */
        static final ReferenceQueue<Class<?>> subclassAuditsQueue =
            new ReferenceQueue<>();
    }

　Caches類中包含了兩個成員subclassAudits和subclasseAuditsQueue：
　　subclassAudits——該成員屬性提供了一個哈希表緩存，該緩存的鍵類型為java.lang.Thread.WeakClassKey，注意看它的值類型是一個java.lang.Boolean類型的，從其代碼注釋可以知道這個哈希表緩存中保存的是所有子類的代碼執行安全性檢測結果；
　　subclassAuditsQueue——該成員屬性定義了一個“Queue隊列”，保存了已經審核過的子類弱引用

static class WeakClassKey extends WeakReference<Class<?>>關於弱引用WeakReference，飛機票：Java中關於WeakReference和WeakHashMap的理解

 

 

---

參考

《JAVA高並發程序設計》電子工業出版社

Java並發編程：Thread類的使用