实验探究-ExecutorServiceAPI----未完待续！！！！具体细节问题之后补充

已于 2022-11-29 09:35:37 修改
阅读量573 收藏
点赞数
分类专栏： 线程池相关知识 文章标签： java jvm c++
于 2022-11-26 21:25:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zs18753479279/article/details/128054914
版权

1 isShutDown & isTerminated & executorRunnableError & executorRunnableTask

isShutDown：当调用shutdown()或shutdownNow()方法后返回为true。
isTerminated：当调用shutdown()方法后，并且所有提交的任务完成后返回为true;
isTerminated：当调用shutdownNow()方法后，成功停止后返回为true;
如果线程池任务正常完成，都为false

public class ExecutorServiceTest {
    public static void main(String[] args) throws InterruptedException {
//        isShutdown();
//        isTerminated_1();
//        executorRunnableError();
        executorRunnableTask();
    }
}

1 isShutdown

private static void isShutdown() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        /**
         * void execute(Runnable command);
         */
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        /**
         * 如果此执行器已关闭，则返回true。
         */
        System.out.println(executorService.isShutdown());
        executorService.shutdown();
        System.out.println(executorService.isShutdown());
        /**
         * 执行完 executorService.shutdown(); 之后 还可以执行一个Runnable？不会，抛出异常！！！
         */
        executorService.execute(() -> System.out.println("i will executor after shutdown ..."));
        /**
         * false
         * true
         * Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.thread.excutor.ExecutorServiceTest$$Lambda$2/932583850@cac736f rejected from java.util.concurrent.ThreadPoolExecutor@5e265ba4[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
         * 	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
         * 	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
         * 	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
         * 	at java.util.concurrent.Executors$DelegatedExecutorService.execute(Executors.java:668)
         * 	at com.thread.excutor.ExecutorServiceTest.isShutdown(ExecutorServiceTest.java:32)
         * 	at com.thread.excutor.ExecutorServiceTest.main(ExecutorServiceTest.java:9)
         */
    }

2 isTerminated

private static void isTerminated_1() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(1);
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
        System.out.println("executorService.isShutdown() " + executorService.isShutdown());
        /**
         * 1、当需要用到isTerminated()函数判断线程池中的所有线程是否执行完毕时候，不能直接使用该函数，
         *    必须在shutdown()方法关闭线程池之后才能使用，否则isTerminated()永不为TRUE，线程将一直阻塞在该判断的地方，导致程序最终崩溃。
         * 2、判断全部提交的任务是否完成，当调用shutdown()方法后，并且所有提交的任务完成后返回为true
         */
        System.out.println("1-executorService.isTerminated() " + executorService.isTerminated());
        System.out.println("executorService.isTerminating() " + executorService.isTerminating());

        /**
         * executorService.isShutdown() true
         * executorService.isTerminated() false
         * executorService.isTerminating() true
         */

    }

3 executorRunnableError - IntStream.range(0, 10).boxed().forEach(i -> executorService.execute(() -> System.out.println(1 / 0)));

private static void executorRunnableError() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(10, new MyThreadFactory());
        IntStream.range(0, 10).boxed().forEach(i -> executorService.execute(() -> System.out.println(1 / 0)));
        executorService.shutdown();
        try {
            executorService.awaitTermination(10, TimeUnit.MINUTES);
            System.out.println("============over============");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private static class MyThreadFactory implements ThreadFactory {
        private final static AtomicInteger SEQ = new AtomicInteger();
        @Override
        public Thread newThread(@NotNull Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("My-Thread-" + SEQ.getAndIncrement());
            /**
             *  void uncaughtException(Thread t, Throwable e);
             */
            thread.setUncaughtExceptionHandler((t, e) -> {
                System.out.println("The thread " + t.getName() + " executor failed.");
                System.out.println("=====================");
            });
            return thread;
        }
    }
/**
The thread My-Thread-6 executor failed.
The thread My-Thread-1 executor failed.
=====================
The thread My-Thread-14 executor failed.
=====================
The thread My-Thread-5 executor failed.
=====================
The thread My-Thread-4 executor failed.
=====================
The thread My-Thread-2 executor failed.
=====================
The thread My-Thread-0 executor failed.
=====================
The thread My-Thread-3 executor failed.
=====================
=====================
The thread My-Thread-7 executor failed.
=====================
The thread My-Thread-12 executor failed.
=====================
============over============

Process finished with exit code 0
*/

4 executorRunnableTask-自定义task任务

/**
     *                             | ---->
     * send  ---> store db ---> 10 | ---->
     *                             | ---->
     */
    private static void executorRunnableTask() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10, new MyThreadFactory());
        IntStream.range(0, 10).boxed().forEach(i -> executorService.execute(() ->
        {
            MyTask myTask = new MyTask(i) {
                @Override
                public void error(Throwable e) {
                    System.out.println("The no : " + i + " failed, update status to ERROR.");
                }

                @Override
                public void done() {
                    System.out.println("The no : " + i + " successfully, update status to DONE.");
                }

                @Override
                public void doExecutor() {
                    if (i % 3 == 0) {
                        int time = 1 / 0;
                    }
                }

                @Override
                public void doInit() {
                    // do noting ...
                }
            };
            myTask.run();
        }));

        executorService.shutdown();
        executorService.awaitTermination(10, TimeUnit.MINUTES);
        System.out.println("=======================");
        /**
         * The no : 0 failed, update status to ERROR.
         * The no : 3 failed, update status to ERROR.
         * The no : 2 successfully, update status to DONE.
         * The no : 1 successfully, update status to DONE.
         * The no : 4 successfully, update status to DONE.
         * The no : 5 successfully, update status to DONE.
         * The no : 7 successfully, update status to DONE.
         * The no : 6 failed, update status to ERROR.
         * The no : 8 successfully, update status to DONE.
         * The no : 9 failed, update status to ERROR.
         * =======================
         */
    }
    private abstract static class MyTask implements Runnable {
        public final Integer no;
        public MyTask(Integer no) {
            this.no = no;
        }
        @Override
        public void run() {
            try {
                this.doInit();
                this.doExecutor();
                this.done();
            } catch (Throwable e) {
                this.error(e);
            }
        }
        public abstract void error(Throwable e);
        public abstract void done();
        public abstract void doExecutor();
        public abstract void doInit();
    }

2 任务拒绝 testAbortPolicy & testDiscardPolicy & testDiscardOldestPolicy & testCallerRunsPolicy

任务拒绝模块是线程池的保护部分，线程池有一个最大的容量，当线程池的任务缓存队列已满，并且线程池中的线程数目达到maximumPoolSize时，就需要拒绝掉该任务，采取任务拒绝策略，保护线程池。

package com.thread.excutor;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

public class RejectedExecutionHandlerTest {
    public static void main(String[] args) {
//        testAbortPolicy();
//        testDiscardPolicy();
        testDiscardOldestPolicy();
//        testCallerRunsPolicy();
    }

    /**
     * 由提交任务的线程处理该任务
     */
    private static void testCallerRunsPolicy() {
        ExecutorService executorService = new ThreadPoolExecutor(1,
                2,
                30,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.CallerRunsPolicy());
        IntStream.range(0, 3).boxed().forEach(item -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("yyyy " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.execute(() -> {
            System.out.println("xxxx == " +  Thread.currentThread().getName());
        });
        /**
         * xxxx == main
         * yyyy Thread-1
         * yyyy Thread-0
         * yyyy Thread-1
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

    /**
     * 1、丢弃队列最前面的任务，然后重新提交被拒绝的任务。
     * 2、当任务被拒绝添加时，会抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去。
     *    在rejectedExecution先从任务队列种弹出最先加入的任务，空出一个位置，然后再次执行execute方法把任务加入队列。
     */
    private static void testDiscardOldestPolicy() {
        ExecutorService executorService = new ThreadPoolExecutor(1,
                2,
                30,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.DiscardOldestPolicy());
        IntStream.range(0, 3).boxed().forEach(item -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("yyyy " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.execute(() -> System.out.println("xxxx" + Thread.currentThread().getName()));
        /**
         * yyyy Thread-0
         * yyyy Thread-1
         * xxxxThread-0
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

    /**
     * 不处理新任务，直接丢弃掉
     */
    private static void testDiscardPolicy() {
        ExecutorService executorService = new ThreadPoolExecutor(1,
                2,
                30,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                new ThreadPoolExecutor.DiscardPolicy());
        IntStream.range(0, 3).boxed().forEach(item -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("yyyy");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.execute(() -> System.out.println("xxxx"));
        /**
         * yyyy
         * yyyy
         * yyyy
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

    /**
     * Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.thread.excutor.RejectedExecutionHandlerTest$$Lambda$5/604107971@7637f22 rejected from java.util.concurrent.ThreadPoolExecutor@4926097b[Running, pool size = 2, active threads = 2, queued tasks = 1, completed tasks = 0]
     * 	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
     * 	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
     * 	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
     * 	at com.thread.excutor.RejectedExecutionHandlerTest.testAbortPolicy(RejectedExecutionHandlerTest.java:36)
     * 	at com.thread.excutor.RejectedExecutionHandlerTest.main(RejectedExecutionHandlerTest.java:11)
     * yyyy
     * yyyy
     * yyyy
     *
     * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
     */
    private static void testAbortPolicy() {
        ExecutorService executorService = new ThreadPoolExecutor(1,
                2,
                30,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Thread::new,
                /**
                 * AbortPolicy（默认）：直接抛出RejectedExecutionException异常阻止系统正常运行。
                 * 丢弃任务，并抛出异常：最大承载=maximumPoolSize + BlockingQueue
                 */
                new ThreadPoolExecutor.AbortPolicy());
        IntStream.range(0, 3).boxed().forEach(item -> {
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(10);
                    System.out.println("yyyy");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.execute(() -> System.out.println("xxxx"));

    }
}

3 AllowCoreThreadTimeOut

allowCoreThreadTimeOut 支持回收核心线程，合适定时任务这种回收。

package com.thread.excutor;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

public class TestAllowCoreThreadTimeOut {
    public static void main(String[] args) {
//        getActiveCount();
//        testAllowCoreThreadTimeOut_1();
//        testAllowCoreThreadTimeOut_2();
//        testAllowCoreThreadTimeOut_3();
        testAllowCoreThreadTimeOut_4();
    }

    private static void getActiveCount() {
        /**
         *     public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         */
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        System.out.println("1 - " + executorService.getActiveCount());
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2 - " + executorService.getActiveCount());
        /**
         * 1 - 0
         * 2 - 1
         */
    }

    private static void testAllowCoreThreadTimeOut_1() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        System.out.println("1===" + executorService.getActiveCount());
        IntStream.range(0, 5).boxed().forEach(item -> executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2===" + executorService.getActiveCount());
        /**
         * 不会销毁
         * 1===0
         * 2===0
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

    private static void testAllowCoreThreadTimeOut_2() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.allowCoreThreadTimeOut(true);
        System.out.println("1===" + executorService.getActiveCount());
        IntStream.range(0, 5).boxed().forEach(item -> executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2===" + executorService.getActiveCount());
        /**
         * Exception in thread "main" java.lang.IllegalArgumentException: Core threads must have nonzero keep alive times
         * 	at java.util.concurrent.ThreadPoolExecutor.allowCoreThreadTimeOut(ThreadPoolExecutor.java:1658)
         * 	at com.thread.excutor.TestU.testAllowCoreThreadTimeOut_2(TestU.java:70)
         * 	at com.thread.excutor.TestU.main(TestU.java:12)
         */
    }

    private static void testAllowCoreThreadTimeOut_3() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.setKeepAliveTime(10, TimeUnit.SECONDS);
        executorService.allowCoreThreadTimeOut(true);
        System.out.println("1===" + executorService.getActiveCount());
        IntStream.range(0, 5).boxed().forEach(item -> executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2===" + executorService.getActiveCount());
        /**
         * 程序会自动退出
         * 1===0
         * 2===0
         *
         * Process finished with exit code 0
         */
    }

    private static void testAllowCoreThreadTimeOut_4() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.setKeepAliveTime(10, TimeUnit.SECONDS);
        executorService.allowCoreThreadTimeOut(true);
        System.out.println("1===" + executorService.getActiveCount());
        IntStream.range(0, 5).boxed().forEach(item -> executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        System.out.println("2===" + executorService.getActiveCount());
        executorService.execute(() -> {
            try {
                System.out.println("xxxxxx");
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("3===" + executorService.getActiveCount());
        /**
         * 1===0
         * 2===5
         * xxxxxx
         * 3===1
         *
         * Process finished with exit code 0
         */
    }
}

4 InvokeAny & InvokeAll & submit

public class TestInvokeAllAnySubmit {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
//        testInvokeAny();
//        testInvokeAnyTimeOut();
//        testInvokeAll_1();
//        testInvokeAll_2();
//        testInvokeAllTimeOut();
//        testSubmitRunnable();
        testSubmitRunnable_2();
    }
}

1 testInvokeAny

	/**
     * 当一个结果返回的时候，其他的线程会接着执行吗？
     * 1、invokeAny取得第一个方法的返回值,当第一个任务结束后，会调用interrupt方法中断其它任务。
     * 2、invokeAll具有阻塞性。
     */
    private static void testInvokeAny() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(item ->
                (Callable<Integer>) () -> {
                    TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(1));
                    System.out.println(Thread.currentThread().getName() + " : " + item);
                    return item;
                }).collect(Collectors.toList());
        /**
         *     <T> T invokeAny(Collection<? extends Callable<T>> tasks,
         *                     long timeout, TimeUnit unit)
         *         throws InterruptedException, ExecutionException, TimeoutException;
         */
        Integer vale = executorService.invokeAny(callableList);
        System.out.println("===========finished============");
        System.out.println(vale);
        /**
         * pool-1-thread-2 : 1
         * pool-1-thread-1 : 0
         * pool-1-thread-5 : 4
         * pool-1-thread-4 : 3
         * pool-1-thread-3 : 2
         * ===========finished============
         * 1
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

private static void testInvokeAnyTimeOut() throws ExecutionException, InterruptedException, TimeoutException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(item ->
                (Callable<Integer>) () -> {
                    TimeUnit.SECONDS.sleep(ThreadLocalRandom.current().nextInt(20));
                    System.out.println(Thread.currentThread().getName() + " : " + item);
                    return item;
                }).collect(Collectors.toList());
        /**
         *     <T> T invokeAny(Collection<? extends Callable<T>> tasks,
         *                     long timeout, TimeUnit unit)
         *         throws InterruptedException, ExecutionException, TimeoutException;
         */
        Integer vale = executorService.invokeAny(callableList, 3, TimeUnit.SECONDS);
        System.out.println("===========finished============");
        System.out.println(vale);

        /**
         * 情况1、
         * pool-1-thread-4 : 3
         * ===========finished============
         * 3
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */

        /**
         * 情况2、
         * 在指定时间内取得第一个先执行完任务的结果值，如果超时，抛出TimeoutException，并且interrupt线程。
         *
         * Exception in thread "main" java.util.concurrent.TimeoutException
         * 	at java.util.concurrent.AbstractExecutorService.doInvokeAny(AbstractExecutorService.java:184)
         * 	at java.util.concurrent.AbstractExecutorService.invokeAny(AbstractExecutorService.java:225)
         * 	at com.thread.excutor.TestInvokeAllAnySubmit.testInvokeAnyTimeOut(TestInvokeAllAnySubmit.java:28)
         * 	at com.thread.excutor.TestInvokeAllAnySubmit.main(TestInvokeAllAnySubmit.java:17)
         */
    }

2 testInvokeAll

private static void testInvokeAll_1() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(item ->
                (Callable<Integer>) () -> {
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println(Thread.currentThread().getName() + " : " + item);
                    return item;
                }).collect(Collectors.toList());
        /**
         *     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
         *         throws InterruptedException;
         */
        List<Future<Integer>> futures = executorService.invokeAll(callableList);
        futures.stream().map(item -> {
            try {
                return item.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }).forEach(System.out::println);
        System.out.println("==========finished============");
        /**
         * pool-1-thread-5 : 4
         * pool-1-thread-2 : 1
         * pool-1-thread-1 : 0
         * pool-1-thread-4 : 3
         * pool-1-thread-3 : 2
         * 0
         * 1
         * 2
         * 3
         * 4
         * ==========finished============
         */

    }

private static void testInvokeAll_2() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(item ->
                (Callable<Integer>) () -> {
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println(Thread.currentThread().getName() + " : " + item);
                    return item;
                }).collect(Collectors.toList());
        List<Future<Integer>> futures = executorService.invokeAll(callableList);
        futures.parallelStream().map(item -> {
            try {
                return item.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }).forEach(System.out::println);
        System.out.println("==========finished============");
        /**
         * pool-1-thread-2 : 1
         * pool-1-thread-4 : 3
         * pool-1-thread-1 : 0
         * pool-1-thread-5 : 4
         * pool-1-thread-3 : 2
         * 2
         * 0
         * 3
         * 4
         * 1
         * ==========finished============
         */

    }

private static void testInvokeAllTimeOut() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> callableList = IntStream.range(0, 5).boxed().map(item ->
                (Callable<Integer>) () -> {
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println(Thread.currentThread().getName() + " : " + item);
                    return item;
                }).collect(Collectors.toList());
        List<Future<Integer>> futures = executorService.invokeAll(callableList, 1, TimeUnit.SECONDS);
        futures.parallelStream().map(item -> {
            try {
                return item.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }).forEach(System.out::println);
        System.out.println("==========finished============");
        /**
         * Exception in thread "main" java.util.concurrent.CancellationException
         * 	at java.util.concurrent.FutureTask.report(FutureTask.java:121)
         * 	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
         * 	at com.thread.excutor.TestInvokeAllAnySubmit.lambda$testInvokeAllTimeOut$2(TestInvokeAllAnySubmit.java:35)
         * 	at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)
         * 	at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1382)
         * 	at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
         * 	at java.util.stream.ForEachOps$ForEachTask.compute(ForEachOps.java:291)
         * 	at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:731)
         * 	at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
         * 	at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:401)
         * 	at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:734)
         * 	at java.util.stream.ForEachOps$ForEachOp.evaluateParallel(ForEachOps.java:160)
         * 	at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateParallel(ForEachOps.java:174)
         * 	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:233)
         * 	at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
         * 	at com.thread.excutor.TestInvokeAllAnySubmit.testInvokeAllTimeOut(TestInvokeAllAnySubmit.java:39)
         * 	at com.thread.excutor.TestInvokeAllAnySubmit.main(TestInvokeAllAnySubmit.java:21)
         */

    }

3 testSubmitRunnable

/**
     * <T> Future<T> submit(Runnable task, T result);
     * Future<?> submit(Runnable task);
     * <T> Future<T> submit(Callable<T> task);
     *
     * 在使用线程池的时候，发现除了execute()方法可以执行任务外，还发现有一个方法submit()可以执行任务。
     * submit()的参数既可以是Runnable，又可以是Callable。
     * 适用于需要获取返回值的场景。
     * 调用future get方法时，异常会抛出。如果不调用get方法，则无法获取。
     */
    private static void testSubmitRunnable_2() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        String result = "done";
        Future<String> future = executorService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, result);
        String s = future.get();
        System.out.println(s);
        /**
         * done
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */
    }

    private static void testSubmitRunnable() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future<?> future = executorService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Object o = future.get();
        System.out.println("result = " + o);
        /**
         * result = null
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         * 程序未执行结束。。。
         */
    }

5 小实验-getQueue().add()

package com.thread.excutor;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class TestU {
    public static void main(String[] args) {
//        getQueueAdd_1();
//        getQueueAdd_2();
    }
    

    private static void getQueueAdd_2() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.execute(() -> System.out.println("I will be process because of triggered the executor."));
        executorService.getQueue().add(() -> System.out.println("I am added directly into the queue"));
        /**
         * I will be process because of triggered the executor.
         * I am added directly into the queue
         *
         * Process finished with exit code 130 (interrupted by signal 2: SIGINT)
         */

    }

    private static void getQueueAdd_1() {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor)Executors.newFixedThreadPool(5);
        executorService.getQueue().add(() -> System.out.println("I am added directly into the queue"));
        /**
         * 未执行 。。。
         * Process finished with exit code 0
         */
    }
}
@Autowire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ScheduledExecutorService API计划任务使用
pys52055的博客
10-05 331
使用callable进行延迟运行 public class MyCallableA implements Callable<String> { @Override public String call() throws Exception { String name = Thread.currentThread().getName(); System.out.println(name+" callA start "+ System.currentTimeMillis());
tech1-temple-java：Java概念证明存储库
01-29
tech1-temple-java 欢迎使用有关Java生态系统的概念证明库愿原力与你同在 概念证明： ...身份验证和安全性-类型，授权，最佳做法 ...DropWizard —与DAO，服务，资源层的单元测试一对多关系 ... 未完待续...
ExecutorService的API
Howie_zhw的博客
06-24 733
实现Runnable的线程类不能够获取到线程的执行结果。 java.util.concurrent.ExecutorService的API Future submit(Callable task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。這个可以通过Future.get()获取线程的返回结果。  Future submit(Runnable
七、ExecutorService的API
qq_30118563的博客
11-15 993
七、ExecutorService的API 7.1 API overview 首先来概览一下，这个接口大概有哪些重要API： invokeAny() 与 invokeAll() 具有阻塞特性 invokeAny() 取得第一个完成任务的结果值，当第一个任务执行完成后，调用interrupt() 中断其他任务，所以可以结合if（Thread.intterruptted()）决定任务是否继续运...
ExecutorService API的使用
pys52055的博客
10-04 162
T invokeAny(Collection<? extends Callable> tasks) throws InterruptedException, ExecutionException; 方法取得第一个完成任务的返回结果，具有线程阻塞特性，当第一个任务完成后会调用interrupt()方法中断其他任务，所有其他任务可以根据 if(Thread.currentThread().isTnterrupt()==true) 来判断任务是否继续执行。 1 无 if(Thread.curren.
三.多线程JUC篇-3.17 ExecutorService API详细讲解
中国华的博客
12-28 265
1.shutdown public class ExecutorServiceExample1 { public static void main(String[] args) throws InterruptedException { isShutDown(); } private static void isShutDown() { ExecutorService executorService = Executors.newSingleThre
9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码
04-16
9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码9--[小黑点的旅行（未完待续）].zip...
H12-311.pdf
07-28
（未完待续） 这些题目只是考试的一部分，考生需要具备广泛的 Wireless Local Area Network 知识和技能，以便顺利通过考试。 考试 tips * 考生需要具备广泛的 Wireless Local Area Network 知识和技能。 * 考生...
C语言程序设计-阅读程序题库及答案.docx
11-16
【2.13】未完的问题，但可以看出是关于条件语句和变量赋值的测试，可能考察的是逻辑运算符的优先级和条件判断的正确性。 这些题目覆盖了C语言的核心概念，如数据类型、运算符、流程控制结构、内存管理、输入输出等...
专升本《有机化学》-试卷-答案.pdf
07-13
28. **未完部分**：此部分信息缺失，无法继续分析。 以上知识点涵盖了有机化学中的基本概念、结构、反应机理以及物质性质等多个方面，是专升本《有机化学》考试的重点内容。学习者需要理解和掌握这些知识点，才能在...
Executor关闭操作备份未完成的任务
weixin_37632716的博客
07-10 123
public class TrackingExecutor extends AbstractExecutorService{ private final ExecutorService exec; private final Set<Runnable> tasksCancelledAtShutdown = Collections.synchronized(new HashSet<Runnable>()); ... public List<Runnable>
java中ExecutorService接口
孤云博客
04-02 2814
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) 一、声明 public interface ExecutorService extends Executor 位于java.util.concurrent包下 所有超级接口：Executor 所有已知...
ExecutorService使用
？？？的博客
08-31 415
参考Android API:http://www.android-doc.com/reference/java/util/concurrent/ExecutorService.html eg: ExcecutorService为线程池接口，将线程加进线程池中，execute后不是马上执行，在不久未来异步执行线程。所以会产生并发问题，需要对线程中的共享资源加锁。 import java.uti
（十） ExecutorService
JT的专栏
03-11 336
前言：上一篇FutureTask的执行过程中其实与ExecutorService有关，但是由于对这个知识点不是很熟，所以就略过了，现在专门就这个知识点学习一下。参考博客：Java线程池 ExecutorServicedemo地址：点击打开链接1. ExecutorService的简单使用简单地看了下ExecutorService的API，感觉还是适合一边看源码一边写例子比较靠谱，一上来就写个简单的...
接口ExecutorService的方法使用
weixin_40472874的博客
08-04 523
1.ExecutorService接口继承于Executor接口（线程池最顶层父类）,抽象类AbstractExecutorService实现了ExecutorService接口，最常用的线程池类ThreadPoolExecutor就是继承于AbstractExecutorService抽象类。 2.接口ExecutorService 中有很多工具方法，ExecutorService接口中的方法有些与 Future 和Callable有关，所以 Future与Callable 的使用是学习 Executor
ExecutorService线程池
最新发布
qq_27242695的博客
01-29 414
文章目录ExecutorService线程池1 ExecutorService API 介绍1.1 api1.1.1 awaitTermination 方法1.1.2 invokeAll 方法1.1.3 invokeAny方法1.1.4 shutdown 方法1.1.5 shutdownNow方法1.1.6 isShutdown方法1.1.7 submit方法1.1.8 isTerminated方法 ExecutorService线程池 1 ExecutorService API 介绍 1.1 api 1
ExecutorService的 isTerminated()实现子线程先运行完后再推出主线程
u011057161的专栏
07-29 2万+
/** * 先让所有的子线程运行完，再运行主线程*/ public class Main { public static void main(String[] args) { ExecutorService executorService=Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) {
java并发编程：Executor、Executors、ExecutorService
热门推荐
River的博客
05-30 8万+
Executors    在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好...
Java线程池关闭1-shutdown和isTerminated<转>
weixin_34077371的博客
06-03 593
shutdownvoid shutdown()启动一次顺序关闭，执行以前提交的任务，但不接受新任务。若已经关闭，则调用没有其他作用。抛出：SecurityException - 如果安全管理器存在并且关闭，此 ExecutorService 可能操作某些不允许调用者修改的线程（因为它没有保持RuntimePermission("modifyThread")），或者安全管理器的 checkAcces...
CloudEngine交换机Error-Down机制详解与处理
Error-Down机制是华为针对端口可能出现的问题设计的一种自动保护功能，它能够在检测到端口出现异常时，主动将端口状态设置为Down，防止网络性能下降或故障扩散。本文档详细阐述了Error-Down机制触发的各种原因，对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值