public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

public class ThreadPoolExecutorTest {
    @Test
    public void ThreadPoolExecutor執(zhí)行簡(jiǎn)單無(wú)返回值任務(wù)() throws Exception {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建兩個(gè)任務(wù)
        Runnable firstRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("第一個(gè)任務(wù)執(zhí)行");
            }
        };
        Runnable secondRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("第二個(gè)任務(wù)執(zhí)行");
            }
        };
        // 讓線程池執(zhí)行任務(wù)
        threadPoolExecutor.execute(firstRunnable);
        threadPoolExecutor.execute(secondRunnable);
        // 讓主線程睡眠1秒，等待線程池中的任務(wù)被執(zhí)行完畢
        Thread.sleep(1000);
    }
}

public class ThreadPoolExecutorTest {
    @Test
    public void ThreadPoolExecutor執(zhí)行簡(jiǎn)單有返回值任務(wù)() throws Exception {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建兩個(gè)任務(wù)，任務(wù)執(zhí)行完有返回值
        Callable<String> firstCallable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "第一個(gè)任務(wù)返回值";
            }
        };
        Callable<String> secondCallable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "第二個(gè)任務(wù)返回值";
            }
        };
        // 讓線程池執(zhí)行任務(wù)
        Future<String> firstFuture = threadPoolExecutor.submit(firstCallable);
        Future<String> secondFuture = threadPoolExecutor.submit(secondCallable);
        // 獲取執(zhí)行結(jié)果，拿不到結(jié)果會(huì)阻塞在get()方法上
        System.out.println(firstFuture.get());
        System.out.println(secondFuture.get());
    }
}

public class ThreadPoolExecutorTest {
    @Test
    public void ThreadPoolExecutor執(zhí)行簡(jiǎn)單有返回值任務(wù)時(shí)拋出錯(cuò)誤() {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建一個(gè)任務(wù)，任務(wù)有返回值，但是執(zhí)行過(guò)程中拋出異常
        Callable<String> exceptionCallable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                throw new RuntimeException("發(fā)生了異常");
            }
        };
        // 讓線程池執(zhí)行任務(wù)
        Future<String> exceptionFuture = threadPoolExecutor.submit(exceptionCallable);
        try {
            System.out.println(exceptionFuture.get());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

public class ThreadPoolExecutorTest {
    @Test
    public void ThreadPoolExecutor通過(guò)submit的方式來(lái)提交并執(zhí)行Runnable() throws Exception {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建結(jié)果對(duì)象
        MyResult myResult = new MyResult();
        // 創(chuàng)建Runnable對(duì)象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                myResult.setResult("任務(wù)執(zhí)行了");
            }
        };
        // 通過(guò)ThreadPoolExecutor的submit()方法提交Runnable
        Future<MyResult> resultFuture = threadPoolExecutor.submit(runnable, myResult);
        // 獲取執(zhí)行結(jié)果
        MyResult finalResult = resultFuture.get();
        // myResult和finalResult的地址實(shí)際相同
        Assert.assertEquals(myResult, finalResult);
        // 打印執(zhí)行結(jié)果
        System.out.println(resultFuture.get().getResult());
    }
    private static class MyResult {
        String result;
        public MyResult() {}
        public MyResult(String result) {
            this.result = result;
        }
        public String getResult() {
            return result;
        }
        public void setResult(String result) {
            this.result = result;
        }
    }
}

public class ThreadPoolExecutorTest {
    @Test
    public void 通過(guò)shutdown關(guān)閉線程池() {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建Runnable對(duì)象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    LockSupport.parkNanos(1000 * 1000 * 1000);
                }
                System.out.println(Thread.currentThread().getName() + " 被中斷");
            }
        };
        // 讓線程池執(zhí)行任務(wù)
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        // 調(diào)用shutdown方法關(guān)閉線程池
        threadPoolExecutor.shutdown();
        // 等待3秒觀察現(xiàn)象
        LockSupport.parkNanos(1000 * 1000 * 1000 * 3L);
    }
}

public class ThreadPoolExecutorTest {
    @Test
    public void 通過(guò)shutdownNow關(guān)閉線程池() {
        // 創(chuàng)建一個(gè)線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(300));
        // 創(chuàng)建Runnable對(duì)象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    LockSupport.parkNanos(1000 * 1000 * 1000);
                }
                System.out.println(Thread.currentThread().getName() + " 被中斷");
            }
        };
        // 讓線程池執(zhí)行任務(wù)
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        // 調(diào)用shutdown方法關(guān)閉線程池
        threadPoolExecutor.shutdownNow();
        // 等待3秒觀察現(xiàn)象
        LockSupport.parkNanos(1000 * 1000 * 1000 * 3L);
    }
}