public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);//通过自旋锁不断的修改线程池状态，直到修改成功为止
            interruptIdleWorkers();
            onShutdown(); // 空实现，子类可以覆盖
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP);//通过自旋锁不断的修改线程池状态，直到修改成功为止
            interruptWorkers();
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

先来说共同点：

1. 都是public的；
2. 调用这两个方法之后，调用execute()方法添加新任务都会被拒绝；
3. 都会对线程发出中断；
4. 执行线程中断和修改状态前，都会加锁；
5. 如果阻塞队列中没有任务而且没有运行的线程，两个方法都会将线程池状态修改为TERMINATED，这个操作是在tryTerminate()中完成的；
6. 调用这两个方法都会对正在运行的线程发出中断，但是不会强行销毁线程，因此尽管执行了这两个方法，线程池可能还会运行一段时间。

下面来看一下两者的不同点：

1. 修改线程池的状态不同，shutdown()将状态修改为SHUTDOWN，shutdownNow()将状态修改为STOP，修改状态时，调用的方法都是相同的：

	//入参是目标状态
    private void advanceRunState(int targetState) {
        for (;;) {
            int c = ctl.get();
            if (runStateAtLeast(c, targetState) ||
                ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
                break;
        }
    }

    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        //新建List对象，用于存储阻塞队列中的任务
        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
        q.drainTo(taskList);//清空阻塞队列，将任务放到新建的List中
        if (!q.isEmpty()) {
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }

    final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            if (workerCountOf(c) != 0) { 
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
        }
    }