public interface Executor {

/**
ÔÚδÀ´Ä³¸öʱ¼äÖ´Ðиø¶¨µÄÃüÁî¡£¸ÃÃüÁî¿ÉÄÜÔÚеÄÏ̡߳¢ÒÑÈë³ØµÄÏ̻߳òÕßÕýµ÷ÓõÄÏß³ÌÖÐÖ´ÐУ¬
ÕâÓÉ Executor ʵÏÖ¾ö¶¨¡£
*
* @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);
}

Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
 ...

class ThreadPerTaskExecutor implements Executor {
     public void execute(Runnable r) {
         new Thread(r).start();
     }
 }

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> T invokeAny(Collection<? extends Callable<T>> tasks) 
        throws InterruptedException, ExecutionException; 
     ...
}

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
}

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
        if (tasks == null)
            throw new NullPointerException();
        //´´½¨Ò»¸ölist±£´æËùÓеĽá¹û
        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<T> t : tasks) {
                RunnableFuture<T> f = newTaskFor(t);
                futures.add(f);
                execute(f);   //ÔËÐÐÈÎÎñ
            }
            for (Future<T> f : futures) {
                if (!f.isDone()) {    //ÒÀ´ÎÈ¡½á¹û
                    try {
                        f.get();     //ÕâÀïʹÓÃgetÊÇΪÁ˵ȴýÔËÐÐÍê³É£¬Èç¹ûûÍê³É¾Í»á×èÈû
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)   //Èç¹û·¢ÉúÒì³££¬ÔòÈ¡ÏûËùÓÐÈÎÎñ
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
}

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) {
////´´½¨µÄÏß³ÌÒÔ¡°pool-N-thread-M¡±ÃüÃû£¬NÊǸù¤³§µÄÐòºÅ£¬MÊÇÏ̺߳Å
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
//ÉèΪ·Çºǫ́Ïß³Ì
if (t.isDaemon())
t.setDaemon(false);
//ÓÅÏȼ¶Îªnormal
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}

protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
   private boolean isPaused;
   private ReentrantLock pauseLock = new ReentrantLock();
   private Condition unpaused = pauseLock.newCondition();

public PausableThreadPoolExecutor(...) { super(...); }
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
pauseLock.lock();
try {
while (isPaused) unpaused.await();
} catch(InterruptedException ie) {
t.interrupt();
} finally {
pauseLock.unlock();
}
}
public void pause() {
pauseLock.lock();
try {
isPaused = true;
} finally {
pauseLock.unlock();
}
}
public void resume() {
pauseLock.lock();
try {
isPaused = false;
unpaused.signalAll();
} finally {
pauseLock.unlock();
}
}
}

   //Ô­×Ó±äÁ¿
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
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;

public class Test1 {
    public static void main(String[] args) {
            final int COUNT_BITS = Integer.SIZE - 3;
            final int CAPACITY   = (1 << COUNT_BITS) - 1;

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

System.out.println(Integer.toBinaryString(CAPACITY));
System.out.println(Integer.toBinaryString(RUNNING));
System.out.println(Integer.toBinaryString(SHUTDOWN));
System.out.println(Integer.toBinaryString(STOP));
System.out.println(Integer.toBinaryString(TIDYING));
System.out.println(Integer.toBinaryString(TERMINATED));
}
}

11111111111111111111111111111
11100000000000000000000000000000
0
100000000000000000000000000000
1000000000000000000000000000000
1100000000000000000000000000000

111 - RUNNING
000 - SHUTDOWN
001 - STOP
010 - TIDYING
011 - TERMINATED

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
       
        int c = ctl.get();
        /**·ÖÈý²½Ö´ÐÐ
         * Èç¹ûworkerCount<corePoolSize,Ôò´´½¨Ò»¸öÐÂÏß³ÌÖ´ÐиÃÈÎÎñ
         */
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true)) //´´½¨³É¹¦Ôòreturn
                return;
            c = ctl.get(); //´´½¨Ê§°ÜÖØжÁȡ״̬£¬Ëæʱ±£³Ö״̬µÄ×îÐÂ
        }
        /**
         * workerCount>=corePoolSize,ÅжÏÏ̳߳ØÊÇ·ñ´¦ÓÚÔËÐÐ״̬£¬ÔÙ½«ÈÎÎñ¼ÓÈë¶ÓÁÐ
         * */
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();     //ÓÃÓÚdouble check
            //Èç¹ûÏ̳߳ش¦ÓÚ·ÇÔËÐÐ̬£¬Ôò½«ÈÎÎñ´Ó»º´æ¶ÓÁÐÖÐɾ³ý
            if (! isRunning(recheck) && remove(command)) 
                reject(command);  //¾Ü¾øÈÎÎñ
            else if (workerCountOf(recheck) == 0) //Èç¹û»î¶¯Ïß³ÌÊýΪ0£¬Ôò´´½¨ÐÂÏß³Ì
                addWorker(null, false);
        }
        //Èç¹ûÏ̳߳ز»´¦ÓÚRUNNING״̬£¬»òÕßworkQueueÂúÁË£¬ÔòÖ´ÐÐÒÔÏ´úÂë
        else if (!addWorker(command, false))
            reject(command);
    }

private final class Worker extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}

/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
...

/**
     * ¼ì²éÔÚµ±Ç°Ï̳߳Ø״̬ºÍÏÞÖÆÏÂÄÜ·ñ´´½¨Ò»¸öÐÂỊ̈߳¬Èç¹û¿ÉÒÔ£¬»áÏàÓ¦¸Ä±äworkerCount£¬
     * ÿ¸öworker¶¼»áÔËÐÐËûÃǵÄfirstTask
     * @param firstTask µÚÒ»¸öÈÎÎñ
     * @param core trueʹÓÃcorePoolSize×÷Ϊ±ß½ç£¬falseʹÓÃmaximumPoolSize
     * @return false Ï̳߳عرջòÕßÒѾ­¾ß±¸¹Ø±ÕµÄÌõ¼þ»òÕßÏ̹߳¤³§Ã»Óд´½¨ÐÂÏß³Ì
     */

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

// Ö»Óе±rs < SHUTDOWN²ÅÓпÉÄܽÓÊÜÐÂÈÎÎñ
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;

for (;;) {
int wc = workerCountOf(c); //¹¤×÷Ïß³ÌÊýÁ¿
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize)) //²»ºÏ·¨Ôò·µ»Ø
return false;
if (compareAndIncrementWorkerCount(c)) //½«¹¤×÷Ïß³ÌÊýÁ¿+1
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs) //ÅжÏÏ̳߳Ø״̬ÓÐûÓиı䣬¸Ä±äÁËÔò½øÐÐÍâÑ­»·£¬·ñÔòÖ»½øÐÐÄÚÑ­»·
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//´´½¨ÐÂÏß³Ì
Worker w = new Worker(firstTask);
Thread t = w.thread;

final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//Ôٴμì²é״̬£¬·ÀÖ¹ThreadFactory´´½¨Ïß³Ìʧ°Ü»òÕß״̬¸Ä±äÁË
int c = ctl.get();
int rs = runStateOf(c);

if (t == null ||
(rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null))) {
decrementWorkerCount(); //¼õÉÙÏß³ÌÊýÁ¿
tryTerminate();//³¢ÊÔÖÐÖ¹Ïß³Ì
return false;
}

workers.add(w);//Ìí¼Óµ½¹¤×÷Ïß³ÌSet¼¯ºÏÖÐ

int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
} finally {
mainLock.unlock();
}

t.start();//Ö´ÐÐÈÎÎñ
//״̬±ä³ÉÁËSTOP£¨µ÷ÓÃÁËshutdownNow·½·¨£©
if (runStateOf(ctl.get()) == STOP && ! t.isInterrupted())
t.interrupt();

return true;
}

final void runWorker(Worker w) {
        Runnable task = w.firstTask;
        w.firstTask = null;
        boolean completedAbruptly = true;//Ïß³ÌÊÇ·ñÒì³£ÖÐÖ¹
        try {
            //ÏÈÈ¡firstTask£¬ÔÙ´Ó¶ÓÁÐÖÐÈ¡ÈÎÎñÖ±µ½Îªnull
            while (task != null || (task = getTask()) != null) {
                w.lock();
                clearInterruptsForTaskRun();
                try {
                    beforeExecute(w.thread, task);//ʵÏÖ¹³×Ó·½·¨
                    Throwable thrown = null;
                    try {
                        task.run();//ÔËÐÐÈÎÎñ
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);//ʵÏÖ¹³×Ó·½·¨
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;//³É¹¦ÔËÐУ¬ËµÃ÷ûÓÐÒì³£ÖÐÖ¹
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }