桃园结义 , 版权所有丨如未注明 , 均为原创丨转载请注明

深入理解Java的Future模式

桃园小编 735次浏览 0个评论 扫描二维码

优化转载自:彻底理解Java的Future模式

    先上一个场景:假如你突然想做饭,但是没有厨具,也没有食材。网上购买厨具比较方便,食材去超市买更放心。
    实现分析:在快递员送厨具的期间,我们肯定不会闲着,可以去超市买食材。所以,在主线程里面另起一个子线程去网购厨具。
    但是,子线程执行的结果是要返回厨具的,而run方法是没有返回值的。所以,这才是难点,需要好好考虑一下。
    

一、模拟代码(普通线程)

/**
 * @Description: TODO
 * @author taohanlin
 * @date 2018年7月4日 下午1:07:40
 */
public class CommonCook {

	public static void main(String[] args) throws InterruptedException {

		long startTime = System.currentTimeMillis();

		// 第一步,网购厨具
		OnlineShopping thread = new OnlineShopping();
		thread.start();
		thread.join();// 保证厨具送到

		// 第二步,去超市购买食材
		Thread.sleep(2000);// 模拟购买食材时间
		Shicai shicai = new Shicai();
		System.out.println("第二步,食材到位");

		// 第三步,用厨具烹饪食材
		System.out.println("第三步,开始展现厨艺");
		cook(thread.chuju, shicai);

		System.out.println("总共用时:" + (System.currentTimeMillis() - startTime) + "ms");

	}

	// 网购厨具线程
	static class OnlineShopping extends Thread {

		private Chuju chuju;

		@Override
		public void run() {
			System.out.println("第一步:下单");
			System.out.println("第一步:等到送货");
			try {
				Thread.sleep(5000); // 模拟送货时间
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("第一步:快递送到");
			chuju = new Chuju();
		}
	}

	// 用厨具烹饪食材
	static void cook(Chuju chuju, Shicai shicai) {
	}

	// 厨具类
	static class Chuju {
	}

	// 食材类
	static class Shicai {
	}

}

打印结果:

第一步:下单
第一步:等到送货
第一步:快递送到
第二步,食材到位
第三步,开始展现厨艺
总共用时:7011ms

    可以看到,多线程已经失去了意义。在厨具送到期间,我们不能干任何事。对应代码,就是调用join方法阻塞主线程。
    有人问了,不阻塞主线程行不行???
    不行!!!

    从代码来看的话,run方法不执行完,属性chuju就没有被赋值,还是null。换句话说,没有厨具,怎么做饭。
    Java现在的多线程机制,核心方法run是没有返回值的;如果要保存run方法里面的计算结果,必须等待run方法计算完,无论计算过程多么耗时。
    面对这种尴尬的处境,程序员就会想:在子线程run方法计算的期间,能不能在主线程里面继续异步执行???
    Where there is a will,there is a way!!!
    这种想法的核心就是Future模式,下面先应用一下Java自己实现的Future模式。

二、模拟代码(Future模式)

/**
 * @Description: TODO
 * @author taohanlin
 * @date 2018年7月4日 下午1:06:52
 */
public class FutureCook {

	public static void main(String[] args) throws InterruptedException, ExecutionException {

		long startTime = System.currentTimeMillis();
		// 第一步,网购餐具
		Callable<Chuju> onlineShopping = new Callable<Chuju>() {

			@Override
			public Chuju call() throws Exception {
				System.out.println("第一步:下单");
				System.out.println("第一步:等待送货");
				Thread.sleep(5000);// 模拟送货时间
				System.out.println("第一步:快递送到");
				return new Chuju();
			}
		};

		FutureTask<Chuju> task = new FutureTask<Chuju>(onlineShopping);
		new Thread(task).start();

		// 第二步,去超市购买食材
		Thread.sleep(2000);// 模拟购买食材时间
		Shicai shicai = new Shicai();
		System.out.println("第二步:食材到位");

		// 第三步,用餐具烹饪食材
		if (!task.isDone()) {// 联系快递员,询问是否到货
			System.out.println("第三步:厨具还没到,心情好就等着(心情不好就调用cancel方法取消订单)");
		}
		Chuju chuju = task.get();
		System.out.println("第三步:厨具到位,开始展现厨艺");
		cook(chuju, shicai);

		System.out.println("总共用时:" + (System.currentTimeMillis() - startTime) + "ms");

	}

	// 用厨具烹饪食材
	static void cook(Chuju chuju, Shicai shicai) {
	}

	// 厨具类
	static class Chuju {
	}

	// 食材类
	static class Shicai {
	}
}

打印结果:

第一步:下单
第一步:等待送货
第二步:食材到位
第三步:厨具还没到,心情好就等着(心情不好就调用cancel方法取消订单)
第一步:快递送到
第三步:厨具到位,开始展现厨艺
总共用时:5003ms

    可以看见,在快递员送厨具的期间,我们没有闲着,可以去买食材;而且我们知道厨具到没到,甚至可以在厨具没到的时候,取消订单不要了。

    面具体分析一下第二段代码:
    1)把耗时的网购厨具逻辑,封装到了一个Callable的call方法里面。

@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;
}

    Callable接口可以看作是Runnable接口的补充,call方法带有返回值,并且可以抛出异常。

    

    2)把Callable实例当作参数,生成一个FutureTask的对象,然后把这个对象当作一个Runnable,作为参数另起线程。

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
    }

    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

    这个继承体系中的核心接口是Future。Future的核心思想是:一个方法f,计算过程可能非常耗时,等待 这个继承体系中的核心接口是Future。Future的核心思想是:一个方法f,计算过程可能非常耗时,等待f返回,显然不明智。可以在调用f的时候,立马返回一个Future,可以通过Future这个数据结构去控制方法f的计算过程。

这里的控制包括:
    get方法:获取计算结果(如果还没计算完,也是必须等待的)
    cancel方法:还没计算完,可以取消计算过程
    isDone方法:判断是否计算完
    isCancelled方法:判断计算是否被取消
    这些接口的设计很完美,FutureTask的实现注定不会简单,后面再说。

    3)在第三步里面,调用了isDone方法查看状态,然后直接调用task.get方法获取厨具,不过这时还没送到,所以还是会等待3秒。对比第一段代码的执行结果,这里我们节省了2秒。这是因为在快递员送货期间,我们去超市购买食材,这两件事在同一时间段内异步执行。

    通过以上3步,我们就完成了对Java原生Future模式最基本的应用。下面具体分析下FutureTask的实现.

    既然FutureTask也是一个Runnable,那就看看它的run方法:

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable; // 这里的callable是从构造方法里面传人的
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex); // 保存call方法抛出的异常
                }
                if (ran)
                    set(result); // 保存call方法的执行结果
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

     先看try语句块里面的逻辑,发现run方法的主要逻辑就是运行Callable的call方法,然后将保存结果或者异常(用的一个属性result)。这里比较难想到的是,将call方法抛出的异常也保存起来了。

    把FutureTask看作一个Future,那么它的作用就是控制Callable的call方法的执行过程,在执行的过程中自然会有状态的转换:

    1)一个FutureTask新建出来,state就是NEW状态;COMPETING和INTERRUPTING用的进行时,表示瞬时状态,存在时间极短(为什么要设立这种状态???不解);NORMAL代表顺利完成;EXCEPTIONAL代表执行过程出现异常;CANCELED代表执行过程被取消;INTERRUPTED被中断
    2)执行过程顺利完成:NEW -> COMPLETING -> NORMAL
    3)执行过程出现异常:NEW -> COMPLETING -> EXCEPTIONAL
    4)执行过程被取消:NEW -> CANCELLED
    5)执行过程中,线程中断:NEW -> INTERRUPTING -> INTERRUPTED
    代码中状态判断、CAS操作等细节,请读者自己阅读。

百度已收录

桃园结义 , 版权所有丨如未注明 , 均为原创丨转载请注明深入理解Java的Future模式

您必须 登录 才能发表评论!