JDK源碼分析系列_Thread

package java.lang;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.LockSupport;

import sun.nio.ch.Interruptible;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
import sun.security.util.SecurityConstants;

/*
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.

When a Java Virtual Machine starts up, there is usually a single 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:
1.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.
2.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.

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.Unless otherwise noted, passing a
{@code null} argument to a constructor or method in this class will cause a {@link NullPointerException} to be thrown.
*/
public class Thread implements Runnable {
    private static native void registerNatives();

    static {
        registerNatives();
    }

    private volatile char name[];
    private int priority;
    private Thread threadQ;
    private long eetop;

    //是否單步執行線程
    private boolean single_step;

    //是否為守護線程
    private boolean daemon = false;

    //JVM狀態
    private boolean stillborn = false;

    //run方法執行的目標代碼
    private Runnable target;

    //線程所屬的線程組
    private ThreadGroup group;

    //線程的類加載器
    private ClassLoader contextClassLoader;

    //線程繼承的AccessControlContext
    private AccessControlContext inheritedAccessControlContext;

    //默認生成的線程名"Thread-" + nextThreadNum()
    private static int threadInitNumber;

    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

    ThreadLocal.ThreadLocalMap threadLocals = null;

    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

    //線程請求棧的深度，如果線程創建者未指定棧深度則其值為0，stackSize如何用完全取決於虛擬機，有的虛擬機會忽略stackSize
    private long stackSize;

    //本地線程終止后，JVM私有的值
    private long nativeParkEventPointer;

    //線程id
    private long tid;

    //用於生成線程ID
    private static long threadSeqNumber;

    //為工具提供的線程狀態值，0表示當前線程還未運行
    private volatile int threadStatus = 0;

    //獲取下一個線程tid
    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }

    /*
    parkBlocker用於調用java.util.concurrent.locks.LockSupport.park方法
    通過java.util.concurrent.locks.LockSupport.setBlocker方法set
    通過java.util.concurrent.locks.LockSupport.getBlocker方法get
    */
    volatile Object parkBlocker;

    /*
    The object in which this thread is blocked in an interruptible I/O operation, if any.
    The blocker's interrupt method should be invoked after setting this thread's interrupt status.
    */
    private volatile Interruptible blocker;
    private final Object blockerLock = new Object();

    void blockedOn(Interruptible b) {
        synchronized (blockerLock) {
            blocker = b;
        }
    }

    //線程的最低優先級
    public final static int MIN_PRIORITY = 1;

    //線程的默認優先級
    public final static int NORM_PRIORITY = 5;

    //線程的最高優先級
    public final static int MAX_PRIORITY = 10;

    //返回當前正在執行線程對象的引用
    public static native Thread currentThread();

    /*
    A hint to the scheduler that the current thread is willing to yield
    its current use of a processor. The scheduler is free to ignore this hint.
    */
    public static native void yield();

    //調用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);
    }

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name.toCharArray();

        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 (parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        this.stackSize = stackSize;

        tid = nextThreadID();
    }

    //線程不支持Object的淺拷貝，取而代之的是構造一個新的線程
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

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

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

    /*
    Causes this thread to begin execution; the Java Virtual Machine calls
    the <code>run</code> method of this thread.
    The result is that two threads are running concurrently: the current thread
    (which returns from the call to the <code>start</code> method) and the other
    thread (which executes its <code>run</code> method).

    public class ThreadTest {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("sakura");
                }
            });
            t1.start();
            t1.join();
            t1.start();
        }
    }

    sakura
    Exception in thread "main" java.lang.IllegalThreadStateException
        at java.lang.Thread.start(Thread.java:705)
        at ThreadTest.main(ThreadTest.java:11)
     */
    public synchronized void start() {
        //threadStatus=0表示線程處於NEW狀態
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {

            }
        }
    }

    private native void start0();

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

    //This method is called by the system to give a Thread a chance to clean up before it actually exits.
    private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        target = null;
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }

    @Deprecated
    public final void stop() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            checkAccess();
            if (this != Thread.currentThread()) {
                security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
            }
        }
        if (threadStatus != 0) {
            resume();
        }

        stop0(new ThreadDeath());
    }

    @Deprecated
    public final synchronized void stop(Throwable obj) {
        throw new UnsupportedOperationException();
    }

    /*
    中斷當前線程，如果不是當前線程中斷自己，會調用checkAccess方法，這可能會拋出SecurityException
    1.如果當前線程由於調用wait、join或sleep方法而阻塞，則中斷狀態會被清除且會拋出InterruptedException
    2.如果線程由於java.nio.channels.InterruptibleChannel類中的InterruptibleChannel的I/O操作而被阻塞，
    調用interrupt方法會使通道關閉且線程的中斷狀態會被重置並拋出ClosedByInterruptException
    3.如果當前線程由於java.nio.channels.Selector而被阻塞，則線程的中斷狀態會被重置，且會立即從selection操作
    返回一個非零值，這就和java.nio.channels.Selector的wakeup()方法被調用一樣
    如果以上條件都不成立，那么線程的中斷狀態被重置，中斷一個非活躍線程不產生影響
    */
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

    /*
    測試當前線程是否被中斷，並且清除中斷狀態
    In other words, if this method were to be called twice in succession, the second
    call would return false (unless the current thread were interrupted again, after
    the first call had cleared its interrupted status and before the second call had examined it).

    A thread interruption ignored because a thread was not alive at the time of the interrupt will
    be reflected by this method returning false.
    */
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

    //測試當前線程是否被中斷，但不清除中斷狀態
    public boolean isInterrupted() {
        return isInterrupted(false);
    }

    private native boolean isInterrupted(boolean ClearInterrupted);

    @Deprecated
    public void destroy() {
        throw new NoSuchMethodError();
    }

    /*
    判斷線程是否處於存活狀態
    A thread is alive if it has been started and has not yet died.
    */
    public final native boolean isAlive();

    @Deprecated
    public final void suspend() {
        checkAccess();
        suspend0();
    }

    @Deprecated
    public final void resume() {
        checkAccess();
        resume0();
    }

    //設置線程的優先級
    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);
        }
    }

    //返回線程優先級
    public final int getPriority() {
        return priority;
    }

    //設置線程的name
    public final synchronized void setName(String name) {
        checkAccess();
        this.name = name.toCharArray();
        if (threadStatus != 0) {
            setNativeName(name);
        }
    }

    //返回線程的name
    public final String getName() {
        return new String(name, true);
    }

    //返回線程所屬的線程組，如果線程已經died，那么會返回null
    public final ThreadGroup getThreadGroup() {
        return group;
    }

    //返回當前線程所在線程組的線程數的估計值
    public static int activeCount() {
        return currentThread().getThreadGroup().activeCount();
    }

    public static int enumerate(Thread tarray[]) {
        return currentThread().getThreadGroup().enumerate(tarray);
    }

    @Deprecated
    public native int countStackFrames();

    /*
    最多等待millis時長當前線程就會死亡，millis=0則要持續等待
    It is recommended that applications not use {@code wait},
    {@code notify}, or {@code notifyAll} on {@code Thread} instances.
    */
    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;
            }
        }
    }

    //最多等待millis微秒+nanos納秒時長當前線程就會死亡
    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);
    }

    /*
    Prints a stack trace of the current thread to the standard error stream.
    This method is used only for debugging.
    */
    public static void dumpStack() {
        new Exception("Stack trace").printStackTrace();
    }

    /*
    設置當前線程為守護線程或用戶線程
    只有當所有運行中的線程都為守護線程時JVM才會退出
    setDaemon方法必須在線程調用start方法之前調用
    */
    public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) {
            throw new IllegalThreadStateException();
        }
        daemon = on;
    }

    //判斷當前線程是否為守護線程
    public final boolean isDaemon() {
        return daemon;
    }

    //確定當前運行線程是否具有修改線程的權限
    public final void checkAccess() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkAccess(this);
        }
    }

    public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName() + "," + getPriority() + "," +
                    group.getName() + "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                    "" + "]";
        }
    }

    //獲取當前線程的ClassLoader
    @CallerSensitive
    public ClassLoader getContextClassLoader() {
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                    Reflection.getCallerClass());
        }
        return contextClassLoader;
    }

    //設置當前線程的ClassLoader
    public void setContextClassLoader(ClassLoader cl) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        contextClassLoader = cl;
    }

    //當且僅當當前線程持有指定對象的監聽器鎖時，返回true，用於斷言：assert Thread.holdsLock(obj);
    public static native boolean holdsLock(Object obj);

    private static final StackTraceElement[] EMPTY_STACK_TRACE
            = new StackTraceElement[0];

    /*
    返回當前線程堆棧轉儲的堆棧跟蹤元素數組
    如果線程沒有start、已經start但沒有被調度器調度或已經終止，那么數組長度為0
    如果數組長度非0，那么數組的第一個元素(索引為0)表示棧的頂部，最后一個元素表示棧底
    */
    public StackTraceElement[] getStackTrace() {
        if (this != Thread.currentThread()) {
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
                security.checkPermission(
                        SecurityConstants.GET_STACK_TRACE_PERMISSION);
            }

            if (!isAlive()) {
                return EMPTY_STACK_TRACE;
            }
            StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[]{this});
            StackTraceElement[] stackTrace = stackTraceArray[0];

            if (stackTrace == null) {
                stackTrace = EMPTY_STACK_TRACE;
            }
            return stackTrace;
        } else {
            return (new Exception()).getStackTrace();
        }
    }

    //返回所有存活線程的堆棧跟蹤數組的map，由於getAllStackTraces時線程仍在執行，所以得到的結果僅僅是一個快照
    public static Map<Thread, StackTraceElement[]> getAllStackTraces() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkPermission(
                    SecurityConstants.GET_STACK_TRACE_PERMISSION);
            security.checkPermission(
                    SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
        }

        Thread[] threads = getThreads();
        StackTraceElement[][] traces = dumpThreads(threads);
        Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);
        for (int i = 0; i < threads.length; i++) {
            StackTraceElement[] stackTrace = traces[i];
            if (stackTrace != null) {
                m.put(threads[i], stackTrace);
            }
        }
        return m;
    }


    private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
            new RuntimePermission("enableContextClassLoaderOverride");

    //Replace with ConcurrentReferenceHashMap when/if it appears in a future release
    private static class Caches {
        //子類安全審核結果的緩存
        static final ConcurrentMap<WeakClassKey, Boolean> subclassAudits =
                new ConcurrentHashMap<>();

        //審核子類的弱引用隊列
        static final ReferenceQueue<Class<?>> subclassAuditsQueue =
                new ReferenceQueue<>();
    }

    private static boolean isCCLOverridden(Class<?> cl) {
        if (cl == Thread.class)
            return false;

        processQueue(Caches.subclassAuditsQueue, Caches.subclassAudits);
        WeakClassKey key = new WeakClassKey(cl, Caches.subclassAuditsQueue);
        Boolean result = Caches.subclassAudits.get(key);
        if (result == null) {
            result = Boolean.valueOf(auditSubclass(cl));
            Caches.subclassAudits.putIfAbsent(key, result);
        }

        return result.booleanValue();
    }

    private static boolean auditSubclass(final Class<?> subcl) {
        Boolean result = AccessController.doPrivileged(
                new PrivilegedAction<Boolean>() {
                    public Boolean run() {
                        for (Class<?> cl = subcl;
                             cl != Thread.class;
                             cl = cl.getSuperclass()) {
                            try {
                                cl.getDeclaredMethod("getContextClassLoader", new Class<?>[0]);
                                return Boolean.TRUE;
                            } catch (NoSuchMethodException ex) {
                            }
                            try {
                                Class<?>[] params = {ClassLoader.class};
                                cl.getDeclaredMethod("setContextClassLoader", params);
                                return Boolean.TRUE;
                            } catch (NoSuchMethodException ex) {
                            }
                        }
                        return Boolean.FALSE;
                    }
                }
        );
        return result.booleanValue();
    }

    private native static StackTraceElement[][] dumpThreads(Thread[] threads);

    private native static Thread[] getThreads();

    /*
    返回當前線程的tid，線程的tid是一個在線程創建時生成的long類型正數
    線程的tid在其生命周期內不會更改且獨一無二，當一個線程終止時，tid可以被重用
    */
    public long getId() {
        return tid;
    }

    //任一時刻線程只能處於其中的一個狀態，且只是虛擬機的狀態值，並不會反映操作系統的線程狀態
    public enum State {
        //線程沒有調用start方法之前的狀態
        NEW,

        //線程在JVM里面運行的狀態，包括就緒和運行
        RUNNABLE,

        //線程等待監視器鎖的狀態
        BLOCKED,

        /*
        一個線程等待其他線程的狀態，這種等待是無限期的
        Object.wait with no timeout
        Thread.join with no timeout
        LockSupport.park
        */
        WAITING,

        /*
        一個線程等待其他線程的狀態，這種等待是有時間限制的
        Thread.sleep
        Object.wait with timeout
        Thread.join with timeout
        LockSupport.parkNanos
        LockSupport.parkUntil
        */
        TIMED_WAITING,

        //線程執行完畢已經退出的狀態
        TERMINATED;
    }

    //返回當前線程的狀態
    public State getState() {
        return sun.misc.VM.toThreadState(threadStatus);
    }

    @FunctionalInterface
    public interface UncaughtExceptionHandler {
        void uncaughtException(Thread t, Throwable e);
    }

    private volatile UncaughtExceptionHandler uncaughtExceptionHandler;

    private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(
                    new RuntimePermission("setDefaultUncaughtExceptionHandler")
            );
        }

        defaultUncaughtExceptionHandler = eh;
    }

    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
        return defaultUncaughtExceptionHandler;
    }

    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
                uncaughtExceptionHandler : group;
    }

    public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        checkAccess();
        uncaughtExceptionHandler = eh;
    }

    private void dispatchUncaughtException(Throwable e) {
        getUncaughtExceptionHandler().uncaughtException(this, e);
    }

    static void processQueue(ReferenceQueue<Class<?>> queue,
                             ConcurrentMap<? extends
                                     WeakReference<Class<?>>, ?> map) {
        Reference<? extends Class<?>> ref;
        while ((ref = queue.poll()) != null) {
            map.remove(ref);
        }
    }

    static class WeakClassKey extends WeakReference<Class<?>> {
        private final int hash;

        WeakClassKey(Class<?> cl, ReferenceQueue<Class<?>> refQueue) {
            super(cl, refQueue);
            hash = System.identityHashCode(cl);
        }

        @Override
        public int hashCode() {
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == this)
                return true;

            if (obj instanceof WeakClassKey) {
                Object referent = get();
                return (referent != null) &&
                        (referent == ((WeakClassKey) obj).get());
            } else {
                return false;
            }
        }
    }

    @sun.misc.Contended("tlr")
    long threadLocalRandomSeed;

    @sun.misc.Contended("tlr")
    int threadLocalRandomProbe;

    @sun.misc.Contended("tlr")
    int threadLocalRandomSecondarySeed;

    private native void setPriority0(int newPriority);

    private native void stop0(Object o);

    private native void suspend0();

    private native void resume0();

    private native void interrupt0();

    private native void setNativeName(String name);
    
}