*/
        NEW, //當執行緒對象對創建後，即進入了新建狀態，如：Thread t = new MyThread()

        /**
         * 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, //當調用執行緒對象的start()方法，執行緒即進入就緒狀態。處於就緒狀態的執行緒，只是說明此執行緒已經做好了準備，隨時等待CPU調度執行，並不是說執行了start()此執行緒立即就會執行

        /**
         * 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, //處於運行狀態中的執行緒由於某種原因，暫時放棄對CPU的使用權，停止執行，此時進入阻塞狀態，直到其進入到就緒狀態，才有機會再次被CPU調用以進入到運行狀態,
　　　　　　　　　　　　

        /**
         * 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, //這個狀態下是不能分配CPU執行的,可使用Object.wait(),Thread,join(),LockSupport.park進入這個狀態

        /**
         * 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,//其實這個狀態和Waiting就是有沒有超時時間的差別，這個狀態下也是不能分配CPU執行的

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED; //在我們的執行緒正常run結束之後或者run一半異常了就是終止狀態

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

public ThreadPoolExecutor(int corePoolSize, //執行緒池核心工作執行緒數量，比如newFixedThreadPool中可以自定義的執行緒數量就是這個參數
                              int maximumPoolSize, //執行緒池所有工作執行緒的數量，比如newFixedThreadPool中的最大工作執行緒就是核心執行緒數，newCachedThreadPool中的最大工作執行緒數是Integer.MAX_VALUE
                              long keepAliveTime, //非核心執行緒存活的時間，當核心執行緒不夠用的時候，創建出來的輔助工作執行緒在完成任務空閑多久後會被回收
                              TimeUnit unit, //上面一個參數的單位，分。秒等
                              BlockingQueue<Runnable> workQueue,//底層使用的阻塞隊列數據結構，比如newFixedThreadPool底層使用LinkedBlockingQueue。工作隊列，保存已提交但是未執行的任務
                              ThreadFactory threadFactory, //創建工作執行緒的工廠，保持默認即可
                              RejectedExecutionHandler handler) { //拒絕策略，即在所有工作執行緒數達到上限，底層阻塞隊列也滿了的時候採取的策略
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;