Callable与Future模式

一. Callable 与 Future

1. 先解释使用场景: 多线程实现方式: 继承Thread类,或实现Runnable接口创建线程类,重写run()方法,方法中调用需要多线程处理的代码,执行时调用start() 方法,但是会发现一个问题,run()方法没有返回值,假设逻辑代码执行完毕后需要返回值怎么办
2. 通过实现 Callable 接口创建线程类,Callable接口中的泛型就是返回值类型,重写接口中的call()方法,该方法就相当于前面的run()方法,不同的是可以返回线程执行完毕后需要的数据
3. 会将返回值封装为一个Future类型的数据
4. 只要不去获取子线程中的数据,在调用该子线程的方法的后续处理是不会阻塞等待的
5. 解释总结:

1. Future: 接口定义了操作异步任务执行的一些方法,例如获取异步任务执行结果,取消任务执行,判断任务是否被取消,判断任务是否执行完毕等
2. Callable:接口中定义了有返回的任务需要实现的方法call(),可以拿到任务执行返回数据

6. Future模式的常用方法:

   • get() 获取返回数据,
   • boolean isDone() 获取是否执行完毕,不管是否有返回值,只要执行完毕都会返回true
   • boolean isCanceller() 如果任务完成前,被取消,则返回true
   • boolean cancel(boolean b) 取消任务执行,如果任务还没执行返回false,如果方法已经执行通过该方法传递true取消成功 返回true,如果方法以及执行完毕,再去传递true,由于已经执行完毕不能再取消了返回false

7. 注意点: 一个 FutureTask,在执行时,不管后面通过 几个 Thread(futureTask).start(),调用执行,只会执行一次

使用示例

1. 自定义线程类,实现Callable接口,重写call() 返回

class TestCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("下载中");
        Thread.sleep(3000L);
        return "下载完毕";
    }
}

2. 运行测试,注意,使用Thread运行Callable中的线程方法,与使用线程池运行Callable中的线程方法

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建有返回值的线程类
        TestCallable testCallable = new TestCallable();
        //2.创建 FutureTask 包装线程类
        FutureTask futureTask = new FutureTask<>(testCallable);
        //3.通过 Thread 运行有返回值的线程类
        new Thread(futureTask).start();
        System.out.println("主线程运行---注意只要没有获取子线程返回的结果,当前主线程是不会阻塞等待的");
        //获取TestCallable线程执行结果
        String resykt = (String) futureTask.get();

        //通过线程池执行Callable线程示例
        ExecutorService service = Executors.newCachedThreadPool();

        Future<String> future = service.submit(testCallable);
        String str = future.get();
        System.out.println(str);
    }
}

Future 原理

自己理解的是跟线程通讯有点像,有两个线程A与B,假设B线程执行完毕后有返回结果,B线程中添加用来存储结果的属性,添加用来标识是否存储完毕的属性,run方法执行完毕后要对存储结果数据的属性赋值,修改标识为完毕状态,调用notify()方法获取锁池中休眠的线程,提供获取执行结果数据的方法,方法中首先判断是否添加完毕,如果没有则调用wait() 方法,进入释放锁并进入等待状态

1. 自定义Future

class MyFuture{
    public String result; //存储结果数据
    public boolean flag = false; //标识是否结果是否设置完毕

	//模拟线程方法执行逻辑代码
    public synchronized void myRun() {
        System.out.println("线程B执行");
        if(flag){
            return;
        }
        try {
            Thread.sleep(5000L);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("线程B执行完毕");
        result = "success";
        flag = true;
        //设置完毕当前释放锁,唤醒锁池中其它线程
        notify();
    }
	
	//获取结果方法
    public synchronized String getResult() throws InterruptedException {
        while (!flag){
            System.out.println("线程B未返回结果进入休眠状态");
            //结果未设置完毕当前进入等待状态
            wait();
        }
        return result;
    }
}

2.调用测试

	public static void main(String[] args) throws ExecutionException, InterruptedException {
      //创建自定义Future对象
       MyFuture myFuture = new MyFuture();
       //通过在线程类的run方法中调用自定义Future,模拟多线程执行
       Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               myFuture.myRun();
           }
       });
       //线程执行
       thread.start();
       System.out.println("线程A执行");
       //获取结果数据
       System.out.println(myFuture.getResult());

    }

FutureTask get方法的缺点

1. 也不能说是缺点: 在FutureTask任务执行后,我们可以调用get()方法获取任务执行结果,但是get()方法是阻塞的,假设在调用get方法后,FutureTask中的任务没有执行完毕,则get就一直阻塞等待到任务执行完毕返回结果值才能继续执行
2. 解决get()方法阻塞问题,使用 “get(long timeout, TimeUnit unit)”, 指定获取结果时的等待时间,指定时间的获取不到则抛出超时异常

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureTaskTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        //1通过FutureTask多线程方式执行任务,返回结果数据
        FutureTask<String> futureTask = new FutureTask<String>(()->{
            System.out.println("模拟异步线程执行业务逻辑");
            TimeUnit.SECONDS.sleep(3);
            return "futureTask运行完毕返回结果数据";
        });
        //2.执行FutureTask线程
        new Thread(futureTask).start();
        //3.获取结果指定等待时间,在指定时间内获取不到抛出TimeoutException异常
        System.out.println(futureTask.get(2L,TimeUnit.SECONDS));

        System.out.println("执行完毕 end");
    }
}

3. 假设工作中要去必须用get()方法怎么办,使用cas轮询,判断FutureTask中任务是否执行完毕,当执行完毕后再调用get去获取结果

	public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        //1通过FutureTask多线程方式执行任务,返回结果数据
        FutureTask<String> futureTask = new FutureTask<String>(()->{
            System.out.println("模拟异步线程执行业务逻辑");
            TimeUnit.SECONDS.sleep(3);
            return "futureTask运行完毕返回结果数据";
        });
        //2.执行FutureTask线程
        new Thread(futureTask).start();

        //3.轮询判断FutureTask中任务是否执行完毕,如果执行完毕了再去获取结果防止阻塞
        while (true){
            if (futureTask.isDone()) {
                String result = futureTask.get();
                break;
            }else {
               System.out.println("任务未执行完毕,走其它流程");
            }
        }
        System.out.println("执行完毕 end");
    }

4. 在第三步中通过轮询机制防止阻塞,判断FutureTask未执行完毕可以进行其他操作,但是这个轮询只是比get()好了一点,还会存在阻塞问题
5. 思考

1. Future执行完毕后,能回调主动通知返回结果吗
2. 多个Future怎么判断哪个最快执行完毕
3. 假设多个Future,怎么实现多线程任务编排,例如两个异步任务相互独立,同时第二个任务又依赖第一个任务的执行结果

6. 解决上述问题提出了 CompletableFuture