如何获取子线程的执行结果

超、凢脫俗 2022-12-11 06:25 147阅读 0赞

## 一 概述 ##

对于线程的管理，我们不仅可以通过线程池进行管理，我们还可以通过Future和Callable进行管理。

## 二 Runnable的缺陷 ##

Runnable接口无法返回一个值返回。

**Runnable接口源码**

@FunctionalInterface
    public interface Runnable {
        //void方法，不存在返回值
        public abstract void run();
    }

Runnable接口不能抛出checked Exception。

## 三 Callable接口 ##

**Callable接口源码**

@FunctionalInterface
    public interface Callable<V> {
        //返回值为泛型V，可抛出异常
        V call() throws Exception;
    }

## 四 Future接口 ##

Future接口的核心思想是，处理一个方法非常耗时，系统没有必要阻塞在这个方法上等方法的返回，这时候我们可以让子线程来处理这个耗时的方法，当子线程在处理这个耗时的方法是，系统可以通过主线程去处理其他任务，同时可以利用Future类控制方法的返回或取消方法的执行。

**Future接口源码**

public interface Future<V> {
        /**
         *取消任务的执行，mayInterruptIfRunning表示是否中断正在执行的任务
         *情况一：如果这个任务还没开始执行，那么这种情况最简单，任务回被正常的取消，未来也不会被执行 
                 并返回true
         *情况二：如果任务已经完成，或者已经取消，那么cancel()方法会执行失败，方法返回false
         *情况三：如果这个任务已经开始执行，此时这个取消方法将不会直接取消这个任务，而是会根据我们所 
                 填的参数mayInterruptIfRunning做判断。
                 传入false时，对已经执行的任务时没有影响，而那些未开始执行的任务只会被标记，在以后它
                 执行的时候应该也不会执行。
                 传入true时，会正常去尝试执行中断。*/
        boolean cancel(boolean mayInterruptIfRunning);
      
        //判断任务是否执行完毕，执行完毕并不代表任务被成功执行(包括中断和取消)
        boolean isDone();
        
        /**
         *获取任务的返回结果
         *情况一：任务正常完成，get方法会立即返回结果。
         *情况二：任务尚未完成（任务未开始或者进行中），get将阻塞并直到任务完成。
         *情况三：任务执行过程中抛出异常，get方法抛出ExecutionException，是由call()方法产生的异常，
                 不管call()执行时抛出任务异常，get方法都只是抛出ExecutionException异常。
         *情况四：任务被取消并抛出CancellationException。
         *情况五：任务超时抛出TimeoutException。
         **/
        V get() throws InterruptedException, ExecutionException;
        
        //限时获取任务的返回结果
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }

**Future.cancle(true)和Future.cancle(false)所适用的情况**

**Future.cancle(true)**

1.  适用于能够处理interrupt的任务。

**Future.cancle(false)**仅用于避免启动尚未启动的任务

1.  未能处理interrupt的任务
2.  不清楚任务是否支持取消
3.  需要等待已经开始的任务执行完成。

**Callable接口与Future类的关系**

我们可以通过Future接口的get()方法获取Callable接口的返回结果，通过get(time)方法限时获取Callable接口的返回结果，通过Future.isDone()方法来判断任务是否已经执行完了，还可以通过cancel()方法将任务取消。

在子线程的call()方法未执行完毕之前，主线程调用get()方法时会被阻塞，直到call()方法返回结果后，主线程才能够通过Future.get()方法得到结果，然后主线程由阻塞状态切换到可执行状态。

Future接口是一个存储器，它存储了任务执行call()返回的结果，而这个任务的执行时间完全取决于call()方法执行的情况而无法提前确定器执行的时间。

**线程池的submit方法返回Future对象源码**

public interface ExecutorService extends Executor {
        //submit方法会被立即提交且会立即将返回结果返回
        <T> Future<T> submit(Callable<T> task);
    
        <T> Future<T> submit(Runnable task, T result);
    
        Future<?> submit(Runnable task);
    }

线程池提交了任务之后，提交时线程池会立即返回给我们一个空的Future容器。当线程的任务一旦执行完毕，即我们可以获取结果的时候，线程池便会把该结果放到之前给我们的那个空的Future容器中，并不需要重新创建，所以我们便可以从该容器中获得任务执行的结果。

**Future的注意点**

1.  当for循环批量获取Future的结果时，容易发生一部分线程很慢的情况，get方法调用时应使用timeout限制。
2.  Future的生命周期只能前进不能后退。如同线程池的生命周期一样，一旦完全完成了任务，他就会永久停在"已完成"的状态，不能重头再来。

## 五 FutureTask ##

我们可以用FutureTask来获取Future和任务的结果，它是一种包装器，可以将Callable转化成Future和Runnable，因为它同时实现了Future接口和Runnable接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable接口的返回值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70][]

FutureTask源码

public class FutureTask<V> implements RunnableFuture<V> {
         public FutureTask(Callable<V> callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
    
          public FutureTask(Runnable runnable, V result) {
            this.callable = Executors.callable(runnable, result);
            this.state = NEW;       // ensure visibility of callable
        }
    
        public V get() throws InterruptedException, ExecutionException {
            int s = state;
            if (s <= COMPLETING)
                s = awaitDone(false, 0L);
            return report(s);
        }
    
        public V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            if (unit == null)
                throw new NullPointerException();
            int s = state;
            if (s <= COMPLETING &&
                (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
                throw new TimeoutException();
            return report(s);
        }
    }

**FutureTask创建Future实例代码**

public class FutureTaskDemo {
    
        public static void main(String[] args) {
            Task task = new Task();
            FutureTask<Integer> integerFutureTask = new FutureTask<>(task);
            //利用线程的方法
            //new Thread(integerFutureTask).start();
            //线程池方法
            ExecutorService service = Executors.newCachedThreadPool();
            service.submit(integerFutureTask);
            try {
                System.out.println("task运行结果："+integerFutureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
    
    class Task implements Callable<Integer> {
    
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程正在计算");
            Thread.sleep(3000);
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }

由源码与实例代码可知，可以将Callable实例作为参数，生成FutureTask的对象，然后将这个对象当作要给Runnable对象，用线程池或其他线程执行这个Runnable对象，最后通过FutureTask获取刚才执行的结果。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhbG1fZW5jb2Rl_size_16_color_FFFFFF_t_70]: /images/20221123/d314462c661f42f48d66827582a16b32.png