Java 8 - juc - Executor和ExecutorService

柔光的暖阳◎ 2023-10-11 22:42 4阅读 0赞

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    /**
     *
     Executor和ExecutorService是用于管理和调度线程池的接口。
    
     Executor接口是线程执行的简单形式，它只有一个方法execute(Runnable command)，用于执行传入的Runnable任务。
     它将任务提交给线程池执行，但不返回任何结果或提供任何方法来跟踪任务的执行状态或获取任务的结果。
     public interface Executor {
        
     void execute(Runnable command);
     }
     ExecutorService接口继承自Executor接口，是线程池的高级形式。
     它提供了更丰富的方法来管理和控制线程池，包括提交任务、控制任务的执行、获取任务的执行结果等。
    
     public interface ExecutorService extends Executor {
        
         void shutdown();
         List<Runnable> shutdownNow();
         boolean isShutdown();
         boolean isTerminated();
         boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
         <T> Future<T> submit(Callable<T> task);
         <T> Future<T> submit(Runnable task, T result);
         Future<?> submit(Runnable task);
         <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
         <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
         <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
         <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
     }
     ExecutorService接口定义了许多方法，包括：
    
         shutdown()：平缓地关闭线程池，允许已提交的任务继续执行，但不接受新的任务。
         shutdownNow()：立即关闭线程池，尝试取消所有正在执行的任务，并返回未执行的任务列表。
         isShutdown()：检查线程池是否已经关闭。
         isTerminated()：检查线程池中的所有任务是否都已完成。
         awaitTermination(long timeout, TimeUnit unit)：等待线程池中的任务终止，直到超时或者所有任务完成。
         submit(Callable<T> task)：提交一个带有返回值的任务，并返回一个Future对象，可以用于获取任务的执行结果。
         submit(Runnable task, T result)：提交一个带有返回值的任务，并返回一个Future对象，可以用于获取任务的执行结果。
         submit(Runnable task)：提交一个不带返回值的任务，并返回一个Future对象。
         invokeAll(Collection<? extends Callable<T>> tasks)：执行给定的任务集合，并返回一个包含所有任务执行结果的Future列表，该方法会阻塞直到所有任务完成。
         invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)：执行给定的任务集合，并返回一个包含所有任务执行结果的Future列表，该方法会阻塞直到所有任务完成或超时。
         invokeAny(Collection<? extends Callable<T>> tasks)：执行给定的任务集合，返回一个已经完成的任务的执行结果，该方法会阻塞直到有任务完成。
         invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)：执行给定的任务集合，返回一个已经完成的任务的执行结果，该方法会阻塞直到有任务完成或超时。
     通过使用ExecutorService接口，可以更方便地管理和调度线程池，控制任务的执行和获取任务的结果。
     */
    public class MyExecutorServiceExample {
        
        public static void main(String[] args) {
        
            // 创建一个固定大小的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
    
            // 提交任务并获取执行结果
            Future<String> future1 = executorService.submit(() -> {
        
                Thread.sleep(2000);
                return "Task 1 completed.";
            });
    
            Future<Integer> future2 = executorService.submit(() -> {
        
                Thread.sleep(3000);
                return 42;
            });
    
            // 提交不带返回值的任务
            executorService.submit(() -> {
        
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println("Task 3 completed.");
            });
    
            // 关闭线程池
            executorService.shutdown();
    
            try {
        
                // 等待所有任务完成并获取结果
                String result1 = future1.get();
                int result2 = future2.get();
    
                System.out.println(result1);
                System.out.println("Task 2 result: " + result2);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }