多线程与高并发（14）——Executor框架（线程池基础）

﹏ヽ暗。殇╰゛Y 2024-03-31 16:20 80阅读 0赞

### 一、简介 ###

线程是什么，线程是一个任务的工作单元和执行单元。我们在用线程的时候知道，要创建线程，再执行线程。如果任务多的情况呢，会有大量的创建销毁线程的资源消耗，这时候就引入了线程池的概念。  
JDK5开始，把工作单元和执行单元分开，工作单元包括Runnable和Callable，利用Executor来执行任务。  
通过 Executor来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。  
**this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用，调用尚未构造完全的对象的方法可能引发令人疑惑的错误。**

### 二、Executor框架结构 ###

1、**任务：** 包括被执行任务需要实现的接口，Runnable接口或者Callable接口。  
2、**任务的提交和执行：** 包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口（ThreadPoolExecutor和ScheduleThreadPoolExecutor）。ExecutorService接口中补充了任务的提交方法submit()。  
3、**任务的结果（异步计算）：** 包括接口Future和实现Future接口的FutureTask类。  
***Executor翻译过来就是执行器的意思，也就是说，Executor框架的目的就是调度任务进行执行，并得出异步计算的结果。***

#### 1、任务（Runnable和Callable接口） ####

主线程通过实现 Runnable 或者 Callable 接口，创建任务对象，用于后续执行。  
Runnable或Callable接口的实现类都可以被 ThreadPoolExecutor 或ScheduledThreadPoolExecutor 执行。  
区别：Runnable接口不会抛异常或者返回对象，但是 Callable 接口可以。  
代码如下：

@FunctionalInterface
    public interface Callable<V> {
        
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }

@FunctionalInterface
    public interface Runnable {
        
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

#### 2、任务的提交和执行 ####

Executor常用的类图如下：  
![在这里插入图片描述][e06e112bbc444084889bfa281b0b31a9.png]  
任务执行机制的核心接口 Executor源码如下：

public interface Executor {
        
    
        /**
         * Executes the given command at some time in the future.  The command
         * may execute in a new thread, in a pooled thread, or in the calling
         * thread, at the discretion of the {@code Executor} implementation.
         *
         * @param command the runnable task
         * @throws RejectedExecutionException if this task cannot be
         * accepted for execution
         * @throws NullPointerException if command is null
         */
        void execute(Runnable command);
    }

通过代码可以看出，其中定义了任务的执行。  
execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；  
ExecutorService接口中提供了submit()方法，用于提交需要返回值的任务。  
代码如下：

<T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);

线程池会返回一个 Future 类型的对象。

#### 3、任务的结果 ####

Future存储的是未来产生的一个结果，其中的get()方法是阻塞的，用来获取返回值。  
代码如下：

V get() throws InterruptedException, ExecutionException;
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;

使用 get（long timeout，TimeUnit unit）方法的话，如果在 timeout 时间内任务还没有执行完，就会抛出 java.util.concurrent.TimeoutException。  
FutureTask接口表示Future+Runnable，其类图如下：  
![在这里插入图片描述][6b5a51a8f06b44959a6e0590dd187f4d.png]  
**FutureTask表示可以直接创建一个FutureTask对象，交给线程池去执行，并且有返回结果。**

### 三、Executor框架使用 ###

下面这个图出现的次数很多了：  
![在这里插入图片描述][c1dc74abffe2459a8a9f25c059aee424.png]  
1、主线程创建任务对象，这个任务对象实现了Runnable或 Callable接口。  
2、把任务对象交给执行器ExecutorService去执行：

ExecutorService.execute(Runnable command);
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);

3、主线程可以直接创建一个FutureTask对象交给执行器去执行。  
4、主线程可以执行 FutureTask.get()方法来等待任务执行完成。主线程也可以执行 FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

### 四、 示例代码 ###

#### 1、Future ####

submit()和get()方法：

public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            //线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            //提交并执行任务
            Future<String> submit = executorService.submit(() -> {
        
                try {
        
                    Thread.sleep(5000L);
                    System.out.println("5秒过去啦");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                return "我是返回值";
            });
    
            String s = submit.get();
            System.out.println(s);
            //关闭线程池
            executorService.shutdown();
        }

结果如下：

5秒过去啦
    我是返回值

get(long timeout,TimeUnit unit)方法：

public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        
            //线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            //提交并执行任务
            Future<String> submit = executorService.submit(() -> {
        
                try {
        
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                return "我是返回值";
            });
            //3秒就不行了哦
            String s = submit.get(3, TimeUnit.SECONDS);
            System.out.println(s);
            //关闭线程池
            executorService.shutdown();
        }

运行结果如下：  
![在这里插入图片描述][8c07feae2c45413a8df7104f6cd54d44.png]  
抛出异常，且线程阻塞未结束。

#### 2、Callable ####

public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        
            //创建任务
            Callable<String> callable = new Callable<String>() {
        
                @Override
                public String call() throws Exception {
        
                    return "我是callable";
                }
            };
            //线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            //提交并执行任务
            Future<String> submit = executorService.submit(callable);
            //3秒就不行了哦
            String s = submit.get(3, TimeUnit.SECONDS);
            System.out.println(s);
            //关闭线程池
            executorService.shutdown();
        }

执行结果如下：

我是callable

#### 3、FutureTask ####

public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        
            //线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            //创建并执行任务
            FutureTask<String> task = new FutureTask<>(()->{
        
                return "aaaaaaa";
            });
            executorService.submit(task);
            String s = task.get();
            System.out.println(s);
            //关闭线程池
            executorService.shutdown();
        }

执行结果如下：

aaaaaaa

### 五、总结&&常见对比 ###

#### 1、Runnable vs Callable ####

前者无返回值和抛异常，后者有。

#### 2、execute vs submit ####

前者执行不需要返回值的任务，后者执行需要返回值的任务，返回值为Future。

#### 3、shutdown vs shutdownNow ####

**shutdown()** ：关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。（**新任务停止，已存在的要执行完**）  
**shutdownNow()**：关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。（**停止所有任务并返回等待值**）

#### 4、isTerminated vs isShutdown ####

**isTerminated ()** ：调用 shutdown() 方法后，并且所有提交的任务完成后返回为 true。  
**isShutdown()**：调用 shutdown() 方法后返回为 true。

[e06e112bbc444084889bfa281b0b31a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/429d8b8da3de49aa9a4f6c24939becda.png
[6b5a51a8f06b44959a6e0590dd187f4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cc8c31c00a344824ae5e0fbf907d3ef6.png
[c1dc74abffe2459a8a9f25c059aee424.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a8a92a29a1f24bf290ee7182184ade6d.png
[8c07feae2c45413a8df7104f6cd54d44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/41fc8dc0ea0f4cf2970773a3a2f211ea.png