线程池中线程的提交和结束

之前讲了线程池的创建和使用，今天讲下线程的提交和终结

1.提交任务

1.1 void execute(Runnable task)；

提交一个任务，没返回值

1.2 Future<?> submit(Runnable task)；

提交一个任务，有返回值

public class ThreadPool1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> future = executorService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "success";
        });

        try {
            log.debug("result:" + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

可以通过future.get()得到返回值的结果，但是此方法是阻塞的，线程执行完毕后才能取到返回结果

1.3  List<Future<T>> invokeAll(collection<? extends Callable<T>> tasks)  throws InterruptedException

提交所有的任务并且会执行完所有任务

public class ThreadPool2 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();

        List<Future<String>> futures = executorService.invokeAll(Arrays.asList(
                () -> {
                    log.debug("1");
                    return "1";
                },
                () -> {
                    log.debug("2");
                    return "2";
                },
                () -> {
                    log.debug("3");
                    return "3";
                },
                () -> {
                    log.debug("4");
                    return "4";
                }
        ));
        log.debug("main start");
        futures.forEach(f->{
            try {
                log.debug(f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
        log.debug("main end");
    }
}

执行结果：

1.4  T invokeAny(collection<? extends Callable<T>> tasks)  throws InterruptedException, ExecutionException

提交所有任务，但是哪个任务先成功执行完毕则返回此任务的执行结果，其他任务取消

public class ThreadPool2_1 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newCachedThreadPool();

        String future = executorService.invokeAny(Arrays.asList(
                () -> {
                    log.debug("1");
                    return "1";
                },
                () -> {
                    log.debug("2");
                    return "2";
                },
                () -> {
                    log.debug("3");
                    return "3";
                },
                () -> {
                    log.debug("4");
                    return "4";
                }
        ));
        log.debug("main start");
        log.debug("future:" + future);
        log.debug("main end");
    }
}

 执行结果：

2.线程结束/终止

1.shutdown()

调用此方法线程池状态变为SHUTDOWN，此时线程池不会接收新任务，但是已提交的任务会执行完毕，不会阻塞调用线程的执行

public class ThreadPool1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> futures = executorService.submit(() -> {
            log.debug("1");
            return "success1";
        });

        Future<String> futures1 = executorService.submit(() -> {
            log.debug("2");
            return "success2";
        });

        Future<String> futures2 = executorService.submit(() -> {
            log.debug("3");
            return "success3";
        });

        Future<String> futures3 = executorService.submit(() -> {
            log.debug("4");
            return "success4";
        });

        Future<String> futures4 = executorService.submit(() -> {
            log.debug("5");
            return "success5";
        });
        executorService.shutdown();
    }
}

结果：

 

2.shutdownNow()

调用此方法线程池的状态变为STOP，不会接收新任务，且会将队列中的任务取消，并用interrupt的方式中断正在执行的任务

public class ThreadPool1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> futures = executorService.submit(() -> {
            log.debug("1");
            return "success1";
        });

        Future<String> futures1 = executorService.submit(() -> {
            log.debug("2");
            return "success2";
        });

        Future<String> futures2 = executorService.submit(() -> {
            log.debug("3");
            return "success3";
        });

        Future<String> futures3 = executorService.submit(() -> {
            log.debug("4");
            return "success4";
        });

        Future<String> futures4 = executorService.submit(() -> {
            log.debug("5");
            return "success5";
        });
        executorService.shutdownNow();
    }
}

结果：

分析下上面的代码：我定义了只有一个核心线程的线程池，同时submit5个任务，只有task1会进入核心线程执行，剩余task会进入队列，然后执行shutdown()，可以看到在队列中的任务会执行，未被打断；但是执行shutdownNow()，只会执行task1，队列中的任务不会执行

若有不对或不严谨的地方，欢迎大家指正

学无止境，与君共勉！！！