Java基础：线程实现方式源码

╰半橙微兮° 2022-09-11 06:18 115阅读 0赞

# 1 线程实现方式 #

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>实现方式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>实现Runnable接口</td> 
   <td align="left">无返回值，Thread方式也是实现Runnable接口</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>实现Callable接口</td> 
   <td align="left">有返回值</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>实现Executor接口</td> 
   <td align="left">线程池方式，ExecutorService接口继承Executor接口，Executors类使用ExecutorService接口创建线程池</td> 
  </tr> 
 </tbody> 
</table>

# 2 Runnable #

package java.lang;
    
    /**
     * ...
     * @author  Arthur van Hoff
     * @see     java.lang.Thread
     * @see     java.util.concurrent.Callable
     * @since   JDK1.0
     */
    @FunctionalInterface
    public interface Runnable {
        
       
        public abstract void run();
    }

# 3 Callable #

package java.util.concurrent;
    /**
     * ...
     * @see Executor
     * @since 1.5
     * @author Doug Lea
     * @param <V> the result type of method {@code call}
     */
    @FunctionalInterface
    public interface Callable<V> {
        
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }

# 4 Thead #

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;
    
    public
    class Thread implements Runnable {
        
        /* Make sure registerNatives is the first thing <clinit> does. */
        private static native void registerNatives();
        static {
        
            registerNatives();
        }
    
        private volatile String name;
        private int            priority;
        private Thread         threadQ;
        private long           eetop;
    
        /* Whether or not to single_step this thread. */
        private boolean     single_step;
    
        /* Whether or not the thread is a daemon thread. */
        private boolean     daemon = false;
    
        /* JVM state */
        private boolean     stillborn = false;
    
        /* What will be run. */
        private Runnable target;
    
        /* The group of this thread */
        private ThreadGroup group;
    
        /* The context ClassLoader for this thread */
        private ClassLoader contextClassLoader;
    
        /* The inherited AccessControlContext of this thread */
        private AccessControlContext inheritedAccessControlContext;
    
        /* For autonumbering anonymous threads. */
        private static int threadInitNumber;
        private static synchronized int nextThreadNum() {
        
            return threadInitNumber++;
        }
    
        /* ThreadLocal values pertaining to this thread. This map is maintained
         * by the ThreadLocal class. */
        ThreadLocal.ThreadLocalMap threadLocals = null;
    
        /*
         * InheritableThreadLocal values pertaining to this thread. This map is
         * maintained by the InheritableThreadLocal class.
         */
        ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    
        /*
         * The requested stack size for this thread, or 0 if the creator did
         * not specify a stack size.  It is up to the VM to do whatever it
         * likes with this number; some VMs will ignore it.
         */
        private long stackSize;
    
        /*
         * JVM-private state that persists after native thread termination.
         */
        private long nativeParkEventPointer;
    
        /*
         * Thread ID
         */
        private long tid;
    
        /* For generating thread ID */
        private static long threadSeqNumber;
    
        /* Java thread status for tools,
         * initialized to indicate thread 'not yet started'
         */
    
        private volatile int threadStatus = 0;
    
    
        private static synchronized long nextThreadID() {
        
            return ++threadSeqNumber;
        }
    
        /**
         * The argument supplied to the current call to
         * java.util.concurrent.locks.LockSupport.park.
         * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
         * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
         */
        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();
    
        /* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
         */
        void blockedOn(Interruptible b) {
        
            synchronized (blockerLock) {
        
                blocker = b;
            }
        }
    
        /**
         * The minimum priority that a thread can have.
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * The default priority that is assigned to a thread.
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * The maximum priority that a thread can have.
         */
        public final static int MAX_PRIORITY = 10;
    
        /**
         * Returns a reference to the currently executing thread object.
         *
         * @return  the currently executing thread.
         */
        public static native Thread currentThread();
    
        public static native void yield();
    
        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);
        }
    
        /**
         * Initializes a Thread with the current AccessControlContext.
         * @see #init(ThreadGroup,Runnable,String,long,AccessControlContext,boolean)
         */
        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) {
        
                /* Determine if it's an applet or not */
    
                /* If there is a security manager, ask the security manager
                   what to do. */
                if (security != null) {
        
                    g = security.getThreadGroup();
                }
    
                /* If the security doesn't have a strong opinion of the matter
                   use the parent thread group. */
                if (g == null) {
        
                    g = parent.getThreadGroup();
                }
            }
    
            /* checkAccess regardless of whether or not threadgroup is
               explicitly passed in. */
            g.checkAccess();
    
            /*
             * Do we have the required permissions?
             */
            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;
    
            /* Set thread ID */
            tid = nextThreadID();
        }
    
        @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);
        }
    
        /**
         * Creates a new Thread that inherits the given AccessControlContext.
         * This is not a public constructor.
         */
        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 synchronized void start() {
        
            /**
             * This method is not invoked for the main method thread or "system"
             * group threads created/set up by the VM. Any new functionality added
             * to this method in the future may have to also be added to the VM.
             *
             * A zero status value corresponds to state "NEW".
             */
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
    
            /* Notify the group that this thread is about to be started
             * so that it can be added to the group's list of threads
             * and the group's unstarted count can be decremented. */
            group.add(this);
    
            boolean started = false;
            try {
        
                start0();
                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();
    
        @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;
            }
            /* Aggressively null out all reference fields: see bug 4006245 */
            target = null;
            /* Speed the release of some of these resources */
            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);
                }
            }
            // A zero status value corresponds to "NEW", it can't change to
            // not-NEW because we hold the lock.
            if (threadStatus != 0) {
        
                resume(); // Wake up thread if it was suspended; no-op otherwise
            }
    
            // The VM can handle all thread states
            stop0(new ThreadDeath());
        }
    
        @Deprecated
        public final synchronized void stop(Throwable obj) {
        
            throw new UnsupportedOperationException();
        }
    
        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();
        }
    
        public static boolean interrupted() {
        
            return currentThread().isInterrupted(true);
        }
    
        public boolean isInterrupted() {
        
            return isInterrupted(false);
        }
    
        /**
         * Tests if some Thread has been interrupted.  The interrupted state
         * is reset or not based on the value of ClearInterrupted that is
         * passed.
         */
        private native boolean isInterrupted(boolean ClearInterrupted);
    
        @Deprecated
        public void destroy() {
        
            throw new NoSuchMethodError();
        }
    
        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);
            }
        }
    
        /**
         * Returns this thread's priority.
         *
         * @return  this thread's priority.
         * @see     #setPriority
         */
        public final int getPriority() {
        
            return priority;
        }
    
        public final synchronized void setName(String name) {
        
            checkAccess();
            if (name == null) {
        
                throw new NullPointerException("name cannot be null");
            }
    
            this.name = name;
            if (threadStatus != 0) {
        
                setNativeName(name);
            }
        }
    
        /**
         * Returns this thread's name.
         *
         * @return  this thread's name.
         * @see     #setName(String)
         */
        public final String getName() {
        
            return name;
        }
    
        public static int activeCount() {
        
            return currentThread().getThreadGroup().activeCount();
        }
    
        public static int enumerate(Thread tarray[]) {
        
            return currentThread().getThreadGroup().enumerate(tarray);
        }
    
        @Deprecated
        public native int countStackFrames();
    
        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);
        }
    
        public static void dumpStack() {
        
            new Exception("Stack trace").printStackTrace();
        }
    
        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);
            }
        }
    
        /**
         * Returns a string representation of this thread, including the
         * thread's name, priority, and thread group.
         *
         * @return  a string representation of this thread.
         */
        public String toString() {
        
            ThreadGroup group = getThreadGroup();
            if (group != null) {
        
                return "Thread[" + getName() + "," + getPriority() + "," +
                               group.getName() + "]";
            } else {
        
                return "Thread[" + getName() + "," + getPriority() + "," +
                                "" + "]";
            }
        }
    
        @CallerSensitive
        public ClassLoader getContextClassLoader() {
        
            if (contextClassLoader == null)
                return null;
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
        
                ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                       Reflection.getCallerClass());
            }
            return contextClassLoader;
        }
    
        public void setContextClassLoader(ClassLoader cl) {
        
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
        
                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            }
            contextClassLoader = cl;
        }
    
        public static native boolean holdsLock(Object obj);
    
        private static final StackTraceElement[] EMPTY_STACK_TRACE
            = new StackTraceElement[0];
    
        public StackTraceElement[] getStackTrace() {
        
            if (this != Thread.currentThread()) {
        
                // check for getStackTrace permission
                SecurityManager security = System.getSecurityManager();
                if (security != null) {
        
                    security.checkPermission(
                        SecurityConstants.GET_STACK_TRACE_PERMISSION);
                }
                // optimization so we do not call into the vm for threads that
                // have not yet started or have terminated
                if (!isAlive()) {
        
                    return EMPTY_STACK_TRACE;
                }
                StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {
        this});
                StackTraceElement[] stackTrace = stackTraceArray[0];
                // a thread that was alive during the previous isAlive call may have
                // since terminated, therefore not having a stacktrace.
                if (stackTrace == null) {
        
                    stackTrace = EMPTY_STACK_TRACE;
                }
                return stackTrace;
            } else {
        
                // Don't need JVM help for current thread
                return (new Exception()).getStackTrace();
            }
        }
    
        public static Map<Thread, StackTraceElement[]> getAllStackTraces() {
        
            // check for getStackTrace permission
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
        
                security.checkPermission(
                    SecurityConstants.GET_STACK_TRACE_PERMISSION);
                security.checkPermission(
                    SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
            }
    
            // Get a snapshot of the list of all threads
            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);
                }
                // else terminated so we don't put it in the map
            }
            return m;
        }
    
    
        private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
                        new RuntimePermission("enableContextClassLoaderOverride");
    
        /** 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<>();
        }
    
        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();
    
        public long getId() {
        
            return tid;
        }
        
        public enum State {
        
            NEW,
            RUNNABLE,
            BLOCKED,
            WAITING,
            TIMED_WAITING,
    
            /**
             * Thread state for a terminated thread.
             * The thread has completed execution.
             */
            TERMINATED;
        }
    
        public State getState() {
        
            // get current thread state
            return sun.misc.VM.toThreadState(threadStatus);
        }
        
        @FunctionalInterface
        public interface UncaughtExceptionHandler {
        
            /**
             * Method invoked when the given thread terminates due to the
             * given uncaught exception.
             * <p>Any exception thrown by this method will be ignored by the
             * Java Virtual Machine.
             * @param t the thread
             * @param e the exception
             */
            void uncaughtException(Thread t, Throwable e);
        }
    
        // null unless explicitly set
        private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
    
        // null unless explicitly set
        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;
        }
    
        /**
         * Dispatch an uncaught exception to the handler. This method is
         * intended to be called only by the JVM.
         */
        private void dispatchUncaughtException(Throwable e) {
        
            getUncaughtExceptionHandler().uncaughtException(this, e);
        }
    
        /**
         * Removes from the specified map any keys that have been enqueued
         * on the specified reference queue.
         */
        static void processQueue(ReferenceQueue<Class<?>> queue,
                                 ConcurrentMap<? extends
                                 WeakReference<Class<?>>, ?> map)
        {
        
            Reference<? extends Class<?>> ref;
            while((ref = queue.poll()) != null) {
        
                map.remove(ref);
            }
        }
    
        /**
         *  Weak key for Class objects.
         **/
        static class WeakClassKey extends WeakReference<Class<?>> {
        
            /**
             * saved value of the referent's identity hash code, to maintain
             * a consistent hash code after the referent has been cleared
             */
            private final int hash;
    
            /**
             * Create a new WeakClassKey to the given object, registered
             * with a queue.
             */
            WeakClassKey(Class<?> cl, ReferenceQueue<Class<?>> refQueue) {
        
                super(cl, refQueue);
                hash = System.identityHashCode(cl);
            }
    
            /**
             * Returns the identity hash code of the original referent.
             */
            @Override
            public int hashCode() {
        
                return hash;
            }
    
            /**
             * Returns true if the given object is this identical
             * WeakClassKey instance, or, if this object's referent has not
             * been cleared, if the given object is another WeakClassKey
             * instance with the identical non-null referent as this one.
             */
            @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;
                }
            }
        }
    
    
        // The following three initially uninitialized fields are exclusively
        // managed by class java.util.concurrent.ThreadLocalRandom. These
        // fields are used to build the high-performance PRNGs in the
        // concurrent code, and we can not risk accidental false sharing.
        // Hence, the fields are isolated with @Contended.
    
        /** The current seed for a ThreadLocalRandom */
        @sun.misc.Contended("tlr")
        long threadLocalRandomSeed;
    
        /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
        @sun.misc.Contended("tlr")
        int threadLocalRandomProbe;
    
        /** Secondary seed isolated from public ThreadLocalRandom sequence */
        @sun.misc.Contended("tlr")
        int threadLocalRandomSecondarySeed;
    
        /* Some private helper methods */
        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);
    }

# 5 ThreadPool #

## 5.1 Executor接口 ##

package java.util.concurrent;
    
    /**
     * ...
     * @since 1.5
     * @author Doug Lea
     */
    public interface Executor {
        
    
        /**
         * Executes the given command at some time in the future.  The command
         * may execute in a new thread, in a pooled thread, or in the calling
         * thread, at the discretion of the {@code Executor} implementation.
         *
         * @param command the runnable task
         * @throws RejectedExecutionException if this task cannot be
         * accepted for execution
         * @throws NullPointerException if command is null
         */
        void execute(Runnable command);
    }

## 5.2 ExecutorService接口 ##

package java.util.concurrent;
    import java.util.List;
    import java.util.Collection;
    
    /**
     * ...
     * @since 1.5
     * @author Doug Lea
     */
    public interface ExecutorService extends Executor {
        
    
        void shutdown();
    
        List<Runnable> shutdownNow();
    
        boolean isShutdown();
    
        boolean isTerminated();
    
        boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;
    
        <T> Future<T> submit(Callable<T> task);
    
        <T> Future<T> submit(Runnable task, T result);
    
        Future<?> submit(Runnable task);
    
        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException;
    
        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                      long timeout, TimeUnit unit)
            throws InterruptedException;
    
        <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException;
    
      
        <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                        long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }

## 5.3 ##

package java.util.concurrent;
    import java.util.*;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.security.AccessControlContext;
    import java.security.AccessController;
    import java.security.PrivilegedAction;
    import java.security.PrivilegedExceptionAction;
    import java.security.PrivilegedActionException;
    import java.security.AccessControlException;
    import sun.security.util.SecurityConstants;
    
    /**
     * ...
     * @since 1.5
     * @author Doug Lea
     */
    public class Executors {
        
    
        public static ExecutorService newFixedThreadPool(int nThreads) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }
    
        public static ExecutorService newWorkStealingPool(int parallelism) {
        
            return new ForkJoinPool
                (parallelism,
                 ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                 null, true);
        }
    
        public static ExecutorService newWorkStealingPool() {
        
            return new ForkJoinPool
                (Runtime.getRuntime().availableProcessors(),
                 ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                 null, true);
        }
    
        public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>(),
                                          threadFactory);
        }
    
        public static ExecutorService newSingleThreadExecutor() {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }
    
        public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>(),
                                        threadFactory));
        }
    
        public static ExecutorService newCachedThreadPool() {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }
    
        public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>(),
                                          threadFactory);
        }
    
        public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1));
        }
    
        public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1, threadFactory));
        }
    
        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    
        public static ScheduledExecutorService newScheduledThreadPool(
                int corePoolSize, ThreadFactory threadFactory) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
        }
    
        public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
        
            if (executor == null)
                throw new NullPointerException();
            return new DelegatedExecutorService(executor);
        }
    
        public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
        
            if (executor == null)
                throw new NullPointerException();
            return new DelegatedScheduledExecutorService(executor);
        }
    
        public static ThreadFactory defaultThreadFactory() {
        
            return new DefaultThreadFactory();
        }
    
        public static ThreadFactory privilegedThreadFactory() {
        
            return new PrivilegedThreadFactory();
        }
    
        public static <T> Callable<T> callable(Runnable task, T result) {
        
            if (task == null)
                throw new NullPointerException();
            return new RunnableAdapter<T>(task, result);
        }
    
        public static Callable<Object> callable(Runnable task) {
        
            if (task == null)
                throw new NullPointerException();
            return new RunnableAdapter<Object>(task, null);
        }
    
        public static Callable<Object> callable(final PrivilegedAction<?> action) {
        
            if (action == null)
                throw new NullPointerException();
            return new Callable<Object>() {
        
                public Object call() {
         return action.run(); }};
        }
    
        public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
        
            if (action == null)
                throw new NullPointerException();
            return new Callable<Object>() {
        
                public Object call() throws Exception {
         return action.run(); }};
        }
    
        public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
        
            if (callable == null)
                throw new NullPointerException();
            return new PrivilegedCallable<T>(callable);
        }
    
        public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
        
            if (callable == null)
                throw new NullPointerException();
            return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
        }
    
        static final class RunnableAdapter<T> implements Callable<T> {
        
            final Runnable task;
            final T result;
            RunnableAdapter(Runnable task, T result) {
        
                this.task = task;
                this.result = result;
            }
            public T call() {
        
                task.run();
                return result;
            }
        }
    
        /**
         * A callable that runs under established access control settings
         */
        static final class PrivilegedCallable<T> implements Callable<T> {
        
            private final Callable<T> task;
            private final AccessControlContext acc;
    
            PrivilegedCallable(Callable<T> task) {
        
                this.task = task;
                this.acc = AccessController.getContext();
            }
    
            public T call() throws Exception {
        
                try {
        
                    return AccessController.doPrivileged(
                        new PrivilegedExceptionAction<T>() {
        
                            public T run() throws Exception {
        
                                return task.call();
                            }
                        }, acc);
                } catch (PrivilegedActionException e) {
        
                    throw e.getException();
                }
            }
        }
    
        /**
         * A callable that runs under established access control settings and
         * current ClassLoader
         */
        static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
        
            private final Callable<T> task;
            private final AccessControlContext acc;
            private final ClassLoader ccl;
    
            PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
        
                SecurityManager sm = System.getSecurityManager();
                if (sm != null) {
        
                    // Calls to getContextClassLoader from this class
                    // never trigger a security check, but we check
                    // whether our callers have this permission anyways.
                    sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
    
                    // Whether setContextClassLoader turns out to be necessary
                    // or not, we fail fast if permission is not available.
                    sm.checkPermission(new RuntimePermission("setContextClassLoader"));
                }
                this.task = task;
                this.acc = AccessController.getContext();
                this.ccl = Thread.currentThread().getContextClassLoader();
            }
    
            public T call() throws Exception {
        
                try {
        
                    return AccessController.doPrivileged(
                        new PrivilegedExceptionAction<T>() {
        
                            public T run() throws Exception {
        
                                Thread t = Thread.currentThread();
                                ClassLoader cl = t.getContextClassLoader();
                                if (ccl == cl) {
        
                                    return task.call();
                                } else {
        
                                    t.setContextClassLoader(ccl);
                                    try {
        
                                        return task.call();
                                    } finally {
        
                                        t.setContextClassLoader(cl);
                                    }
                                }
                            }
                        }, acc);
                } catch (PrivilegedActionException e) {
        
                    throw e.getException();
                }
            }
        }
    
        /**
         * The default thread factory
         */
        static class DefaultThreadFactory implements ThreadFactory {
        
            private static final AtomicInteger poolNumber = new AtomicInteger(1);
            private final ThreadGroup group;
            private final AtomicInteger threadNumber = new AtomicInteger(1);
            private final String namePrefix;
    
            DefaultThreadFactory() {
        
                SecurityManager s = System.getSecurityManager();
                group = (s != null) ? s.getThreadGroup() :
                                      Thread.currentThread().getThreadGroup();
                namePrefix = "pool-" +
                              poolNumber.getAndIncrement() +
                             "-thread-";
            }
    
            public Thread newThread(Runnable r) {
        
                Thread t = new Thread(group, r,
                                      namePrefix + threadNumber.getAndIncrement(),
                                      0);
                if (t.isDaemon())
                    t.setDaemon(false);
                if (t.getPriority() != Thread.NORM_PRIORITY)
                    t.setPriority(Thread.NORM_PRIORITY);
                return t;
            }
        }
    
        /**
         * Thread factory capturing access control context and class loader
         */
        static class PrivilegedThreadFactory extends DefaultThreadFactory {
        
            private final AccessControlContext acc;
            private final ClassLoader ccl;
    
            PrivilegedThreadFactory() {
        
                super();
                SecurityManager sm = System.getSecurityManager();
                if (sm != null) {
        
                    // Calls to getContextClassLoader from this class
                    // never trigger a security check, but we check
                    // whether our callers have this permission anyways.
                    sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
    
                    // Fail fast
                    sm.checkPermission(new RuntimePermission("setContextClassLoader"));
                }
                this.acc = AccessController.getContext();
                this.ccl = Thread.currentThread().getContextClassLoader();
            }
    
            public Thread newThread(final Runnable r) {
        
                return super.newThread(new Runnable() {
        
                    public void run() {
        
                        AccessController.doPrivileged(new PrivilegedAction<Void>() {
        
                            public Void run() {
        
                                Thread.currentThread().setContextClassLoader(ccl);
                                r.run();
                                return null;
                            }
                        }, acc);
                    }
                });
            }
        }
    
        /**
         * A wrapper class that exposes only the ExecutorService methods
         * of an ExecutorService implementation.
         */
        static class DelegatedExecutorService extends AbstractExecutorService {
        
            private final ExecutorService e;
            DelegatedExecutorService(ExecutorService executor) {
         e = executor; }
            public void execute(Runnable command) {
         e.execute(command); }
            public void shutdown() {
         e.shutdown(); }
            public List<Runnable> shutdownNow() {
         return e.shutdownNow(); }
            public boolean isShutdown() {
         return e.isShutdown(); }
            public boolean isTerminated() {
         return e.isTerminated(); }
            public boolean awaitTermination(long timeout, TimeUnit unit)
                throws InterruptedException {
        
                return e.awaitTermination(timeout, unit);
            }
            public Future<?> submit(Runnable task) {
        
                return e.submit(task);
            }
            public <T> Future<T> submit(Callable<T> task) {
        
                return e.submit(task);
            }
            public <T> Future<T> submit(Runnable task, T result) {
        
                return e.submit(task, result);
            }
            public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
                throws InterruptedException {
        
                return e.invokeAll(tasks);
            }
            public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                                 long timeout, TimeUnit unit)
                throws InterruptedException {
        
                return e.invokeAll(tasks, timeout, unit);
            }
            public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
                throws InterruptedException, ExecutionException {
        
                return e.invokeAny(tasks);
            }
            public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                                   long timeout, TimeUnit unit)
                throws InterruptedException, ExecutionException, TimeoutException {
        
                return e.invokeAny(tasks, timeout, unit);
            }
        }
    
        static class FinalizableDelegatedExecutorService
            extends DelegatedExecutorService {
        
            FinalizableDelegatedExecutorService(ExecutorService executor) {
        
                super(executor);
            }
            protected void finalize() {
        
                super.shutdown();
            }
        }
    
        /**
         * A wrapper class that exposes only the ScheduledExecutorService
         * methods of a ScheduledExecutorService implementation.
         */
        static class DelegatedScheduledExecutorService
                extends DelegatedExecutorService
                implements ScheduledExecutorService {
        
            private final ScheduledExecutorService e;
            DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
        
                super(executor);
                e = executor;
            }
            public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        
                return e.schedule(command, delay, unit);
            }
            public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
        
                return e.schedule(callable, delay, unit);
            }
            public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        
                return e.scheduleAtFixedRate(command, initialDelay, period, unit);
            }
            public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
        
                return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
            }
        }
    
        /** Cannot instantiate. */
        private Executors() {
        }
    }