Future和Callable-治理线程第二大法宝

文章目录

1、Runnable缺陷

Runnable主要有两个缺陷:

不能返回一个返回值
不能抛出异常

2、Callable接口

这两点Callable都能做到；

Future和Callable配合使用:可以用Future.get来获取Callable接口返回的执行结果，还可以通过Future.isDone()来判断任务是否已完成以及取消这个任务，限时获取任务的结果
在call()未执行完毕之前，调用get()的线程（假定此时是主线程）会被阻塞，直到call()方法返回了结果后，此时future.get()才会得到该结果，然后主线程才会切换到runnable状态
所以Future是一个存储器，它存储了call()这个任务的结果，而这个任务的执行时间是无法提前确定的，因为这完全取决于call()方法执行的情况

3、Future类

get()方法:获取结果,future一旦调用get方法，就会阻塞，直到返回结果

get方法的行为取决于Callable任务的状态，只有以下这5种情况:

4、两种用法

future的方法：
get、带时间参数get、isDone、cancel、isCancelled

4.1 用法1:线程池submit方法返回future对象

在这里插入图片描述

示例1:get的基本用法 Onefuture.java

package future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 描述：     演示一个Future的使用方法
 */
public class OneFuture {
    
    

    public static void main(String[] args) {
    
    
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new CallableTask());
        try {
    
    
            System.out.println(future.get());
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
        }
        service.shutdown();
    }

    static class CallableTask implements Callable<Integer> {
    
    

        @Override
        public Integer call() throws Exception {
    
    
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }

}

运行结果

在这里插入图片描述

示例2: Future用法的lamda形式

package future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 描述：     演示一个Future的使用方法,lambda形式
 */
package future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 描述：     演示一个Future的使用方法,lambda形式
 */
public class OneFutureLambda {
    
    

    public static void main(String[] args) {
    
    
        ExecutorService service = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = ()->{
    
    
			Thread.sleep(3000);
			return new Random().nextInt();
        };
        Future<Integer> future = service.submit(callable);
        try {
    
    
            System.out.println(future.get());
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
        }
        service.shutdown();
    }

}

运行结果

在这里插入图片描述

示例3: 多个任务，用future的数组获取结果

package future;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 描述：     演示批量提交任务时，用List来批量接收结果
 */
public class MultiFutures {
    
    

    public static void main(String[] args) throws InterruptedException {
    
    
        ExecutorService service = Executors.newFixedThreadPool(20);
        ArrayList<Future> futures = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
    
    
            Future<Integer> future = service.submit(new CallableTask());
            futures.add(future);
        }
        Thread.sleep(5000);
        for (int i = 0; i < 20; i++) {
    
    
            Future<Integer> future = futures.get(i);
            try {
    
    
                Integer integer = future.get();
                System.out.println(integer);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            } catch (ExecutionException e) {
    
    
                e.printStackTrace();
            }
        }
    }

    static class CallableTask implements Callable<Integer> {
    
    

        @Override
        public Integer call() throws Exception {
    
    
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

运行结果

在这里插入图片描述

示例4:抛出异常

package future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 描述：     演示get方法过程中抛出异常，for循环为了演示抛出Exception的时机：并不是说一产生异常就抛出，直到我们get执行时，才会抛出。
 */
public class GetException {
    
    

    public static void main(String[] args) {
    
    
        ExecutorService service = Executors.newFixedThreadPool(20);
        Future<Integer> future = service.submit(new CallableTask());


        try {
    
    
            for (int i = 0; i < 5; i++) {
    
    
                System.out.println(i);
                Thread.sleep(500);
            }
            System.out.println(future.isDone());
            future.get();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
            System.out.println("InterruptedException异常");
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
            System.out.println("ExecutionException异常");
        }
    }


    static class CallableTask implements Callable<Integer> {
    
    

        @Override
        public Integer call() throws Exception {
    
    
            throw new IllegalArgumentException("Callable抛出异常");
        }
    }
}

运行结果

在这里插入图片描述

示例5 超时获取

package future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 描述：     演示get的超时方法，需要注意超时后处理，调用future.cancel()。演示cancel传入true和false的区别，代表是否中断正在执行的任务。
 */
public class Timeout {
    
    

    private static final Ad DEFAULT_AD = new Ad("无网络时候的默认广告");
    private static final ExecutorService exec = Executors.newFixedThreadPool(10);

    static class Ad {
    
    

        String name;

        public Ad(String name) {
    
    
            this.name = name;
        }

        @Override
        public String toString() {
    
    
            return "Ad{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }


    static class FetchAdTask implements Callable<Ad> {
    
    

        @Override
        public Ad call() throws Exception {
    
    
            try {
    
    
                Thread.sleep(3000);
            } catch (InterruptedException e) {
    
    
                System.out.println("sleep期间被中断了");
                return new Ad("被中断时候的默认广告");
            }
            return new Ad("旅游订票哪家强？找某程");
        }
    }


    public void printAd() {
    
    
        Future<Ad> f = exec.submit(new FetchAdTask());
        Ad ad;
        try {
    
    
            ad = f.get(2000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
    
    
            ad = new Ad("被中断时候的默认广告");
        } catch (ExecutionException e) {
    
    
            ad = new Ad("异常时候的默认广告");
        } catch (TimeoutException e) {
    
    
            ad = new Ad("超时时候的默认广告");
            System.out.println("超时，未获取到广告");
            boolean cancel = f.cancel(true);
            System.out.println("cancel的结果：" + cancel);
        }
        exec.shutdown();
        System.out.println(ad);
    }

    public static void main(String[] args) {
    
    
        Timeout timeout = new Timeout();
        timeout.printAd();
    }
}

运行结果1:当cancel参数为false

在这里插入图片描述
运行结果2: 当cancel参数为true

在这里插入图片描述

4.2 用法2:用FutureTask创建future

可以用FutureTask获得future和任务的结果

package future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

/**
 * 描述：     演示FutureTask的用法
 */
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;
    }
}

在这里插入图片描述

5、Future的注意点

future生命周期不能后退
for循环批量获取future结果，容易发生一部分线程慢的情况，get方法调用使用timeout限制

Future和Callable-治理线程第二大法宝

文章目录

1、Runnable缺陷

2、Callable接口

3、Future类

4、两种用法

4.1 用法1:线程池submit方法返回future对象

4.2 用法2:用FutureTask创建future

5、Future的注意点

猜你喜欢