public static void test02() throws InterruptedException {
    Thread t = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        System.out.println("process i=" + i + "，interrupted：" + Thread.currentThread().isInterrupted());
    }
    });
    t.start();
    Thread.sleep(1);
    t.interrupt();
}

public static void test02() throws InterruptedException {
    Thread t = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        if (Thread.interrupted()) {
            System.out.println("線程已中斷，退出執(zhí)行");
            break;
        }
        System.out.println("process i=" + i + "，interrupted：" + Thread.currentThread().isInterrupted());
    }
    });
    t.start();
    Thread.sleep(1);
    t.interrupt();
}

 /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     *
     * <p>This method does not wait for previously submitted tasks to
     * complete execution.  Use {@link #awaitTermination awaitTermination}
     * to do that.
     *
     * @throws SecurityException {@inheritDoc}
     */
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN); // 1. 把線程池的狀態(tài)設(shè)置為 SHUTDOWN
            interruptIdleWorkers(); // 2. 把空閑的工作線程置為中斷
            onShutdown(); // 3. 一個空實現(xiàn)，暫不用關(guān)注
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

 private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

public static void test01() throws InterruptedException {
        // corePoolSize 是 2，maximumPoolSize 是 2
        ThreadPoolExecutor es = new ThreadPoolExecutor(2, 2,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.prestartAllCoreThreads(); // 啟動所有 worker
        es.execute(new Task()); // Task是一個訪問某網(wǎng)站的 HTTP 請求，跑的慢，后面會貼出來完整代碼，這里把他當做一個跑的慢的異步任務(wù)就行
        es.shutdown();
        es.execute(new Task()); // 在線程池 shutdown() 后 繼續(xù)添加任務(wù)，這里預(yù)期是拋出異常
    }

 /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution. These tasks are drained (removed)
     * from the task queue upon return from this method.
     *
     * <p>This method does not wait for actively executing tasks to
     * terminate.  Use {@link #awaitTermination awaitTermination} to
     * do that.
     *
     * <p>There are no guarantees beyond best-effort attempts to stop
     * processing actively executing tasks.  This implementation
     * cancels tasks via {@link Thread#interrupt}, so any task that
     * fails to respond to interrupts may never terminate.
     *
     * @throws SecurityException {@inheritDoc}
     */
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP); // 1：把線程池設(shè)置為STOP
            interruptWorkers(); // 2.中斷工作線程
            tasks = drainQueue(); // 3.把線程池中的任務(wù)都 drain 出來
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

  /**
     * Interrupts all threads, even if active. Ignores SecurityExceptions
     * (in which case some threads may remain uninterrupted).
     */
    private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

  /**
     * Drains the task queue into a new list, normally using
     * drainTo. But if the queue is a DelayQueue or any other kind of
     * queue for which poll or drainTo may fail to remove some
     * elements, it deletes them one by one.
     */
    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
        q.drainTo(taskList);
        if (!q.isEmpty()) {
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }

public static void test01() throws InterruptedException {
        // corePoolSize 是 1，maximumPoolSize 是 1，無限容量
        ThreadPoolExecutor es = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.prestartAllCoreThreads(); // 啟動所有 worker
        es.execute(new Task()); // Task是一個訪問某網(wǎng)站的 HTTP 請求，跑的慢，后面會貼出來完整代碼，這里把他當做一個跑的慢的異步任務(wù)就行
        es.execute(new Task());
        List<Runnable> result = es.shutdownNow();
        System.out.println(result);
        es.execute(new Task()); // 在線程池 shutdownNow() 后 繼續(xù)添加任務(wù)，這里預(yù)期是拋出異常
    }

public static void test01() throws InterruptedException {
        ThreadPoolExecutor es = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.execute(new Task());
        es.execute(new Task());
        es.execute(new Task());
        Thread shutdownHook = new Thread(() -> {
            es.shutdown();
            try {
                es.awaitTermination(3, TimeUnit.MINUTES);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("等待超時，直接關(guān)閉");
            }
        });
        Runtime.getRuntime().addShutdownHook(shutdownHook);
    }

 public static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("task start");
            for (int i = 0; i < 10; i++) {
                httpGet();
                System.out.println("task execute " + i);
            }
            System.out.println("task finish");
        }
        private void httpGet() {
            String url = "https://stackoverflow.com/";
            String result = "";
            BufferedReader in = null;
            try {
                String urlName = url;
                URL realUrl = new URL(urlName);
                // 打開和URL之間的連接
                URLConnection conn = realUrl.openConnection();
                // 設(shè)置通用的請求屬性
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");
                conn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
                // 建立實際的連接
                conn.connect();
                // 獲取所有響應(yīng)頭字段
                Map<String, List<String>> map = conn.getHeaderFields();
//                 遍歷所有的響應(yīng)頭字段
//                for (String key : map.keySet()) {
//                    System.out.println(key + "--->" + map.get(key));
//                }
                // 定義BufferedReader輸入流來讀取URL的響應(yīng)
                in = new BufferedReader(
                        new InputStreamReader(conn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += "/n" + line;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 使用finally塊來關(guān)閉輸入流
            finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
//            System.out.print(result);
        }
    }