Java多线程编程中Future模式的详解

阅读更多

        Java多线程编程中,常用的多线程设计模式包括:Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述Future模式。

一.Future模式核心思想

        Future模式的核心在于:去除了主函数的等待时间,并使得原本需要等待的时间段可以用于处理其他业务逻辑(根据《Java程序性能优化》)。

        Future模式有点类似于商品订单。在网上购物时,提交订单后,在收货的这段时间里无需一直在家里等候,可以先干别的事情。类推到程序设计中时,当提交请求时,期望得到答复时,如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情,但如果利用Future设计模式就无需等待答复的到来,在等待答复的过程中可以干其他事情。

        例如如下的请求调用过程时序图。当call请求发出时,需要很长的时间才能返回。左边的图需要一直等待,等返回数据后才能继续其他操作;而右边的Future模式的图中客户端则无需等到可以做其他的事情。服务器段接收到请求后立即返回结果给客户端,这个结果并不是真实的结果(是虚拟的结果),也就是先获得一个假数据,然后执行其他操作。

Java多线程编程中Future模式的详解_第1张图片

二. Future模式Java实现

Client的实现

        Client主要完成的功能包括:1. 返回一个FutureData;2.开启一个线程用于构造RealData。

package com.bijian.study;

public class Client {
    
    public Data request(final String string) {
        
        final FutureData futureData = new FutureData();
         
        new Thread(new Runnable() {
            @Override
            public void run() {
                //RealData的构建很慢,所以放在单独的线程中运行
                RealData realData = new RealData(string);
                futureData.setRealData(realData);
            }
        }).start();
         
        return futureData; //先直接返回FutureData
    }
}

Data的实现

        无论是FutureData还是RealData都实现该接口。

package com.bijian.study;

public interface Data {
	
    String getResult() throws InterruptedException;
}

FutureData的实现

        FutureData是Future模式的关键,它实际上是真实数据RealData的代理,封装了获取RealData的等待过程。

package com.bijian.study;

//FutureData是Future模式的关键,它实际上是真实数据RealData的代理,封装了获取RealData的等待过程
public class FutureData implements Data {

    RealData realData = null; //FutureData是RealData的封装
    boolean isReady = false; //是否已经准备好

    public synchronized void setRealData(RealData realData) {
        if (isReady) {
            return;
        }
        this.realData = realData;
        isReady = true;
        notifyAll(); //RealData已经被注入到FutureData中了,通知getResult()方法
    }

    @Override
    public synchronized String getResult() throws InterruptedException {
        if (!isReady) {
            wait(); //一直等到RealData注入到FutureData中
        }
        return realData.getResult();
    }
}

RealData的实现

        RealData是最终需要使用的数据,它的构造函数很慢。

package com.bijian.study;

public class RealData implements Data {
    
    protected String data;
 
    public RealData(String data) {
        //利用sleep方法来表示RealData构造过程是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = "Real " + data;
    }

    @Override
    public String getResult() {
        return data;
    }
}

测试运行

        主函数主要负责调用Client发起请求,并使用返回的数据。

package com.bijian.study;

public class Application {

    public static void main(String[] args) throws InterruptedException {
        
        Client client = new Client();
        //这里会立即返回,因为获取的是FutureData,而非RealData
        Data data = client.request("name");
        //这里可以用一个sleep代替对其他业务逻辑的处理
        //在处理这些业务逻辑过程中,RealData也正在创建,从而充分了利用等待时间
        Thread.sleep(2000);
        //使用真实数据
        System.out.println("数据=" + data.getResult());
    }
}

运行结果:

数据=Real name

 

三.Future模式的JDK内置实现

        由于Future是非常常用的多线程设计模式,因此在JDK中内置了Future模式的实现。这些类在java.util.concurrent包里面。其中最为重要的是FutureTask类,它实现了Runnable接口,作为单独的线程运行。在其run()方法中,通过Sync内部类调用Callable接口,并维护Callable接口的返回对象。当使用FutureTask.get()方法时,将返回Callable接口的返回对象。同样,针对上述的实例,如果使用JDK自带的实现,则需要作如下调整。

        首先,Data接口和FutureData就不需要了,JDK帮我们实现了。

        其次,RealData改为这样:

package com.bijian.study;

import java.util.concurrent.Callable;

public class RealData implements Callable {
    
    protected String data;

    public RealData(String data) {
        this.data = data;
    }

    @Override
    public String call() throws Exception {
        //利用sleep方法来表示真是业务是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Real " + data;
    }
}

        最后,在测试运行时,这样调用:

package com.bijian.study;

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

public class Application {

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

        FutureTask futureTask = new FutureTask(new RealData("name"));
        ExecutorService executor = Executors.newFixedThreadPool(1); //使用线程池
        //执行FutureTask,相当于上例中的client.request("name")发送请求
        executor.submit(futureTask);
        //这里可以用一个sleep代替对其他业务逻辑的处理
        //在处理这些业务逻辑过程中,RealData也正在创建,从而充分了利用等待时间
        Thread.sleep(2000);
        //使用真实数据
        //如果call()没有执行完成依然会等待
        System.out.println("数据=" + futureTask.get());
        
        //当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务,否则将会抛出RejectedExecutionException异常。
        //但是,此时线程池不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。 与它相似的还有一个shutdownNow(),它通过调用Thread.interrupt来实现线程的立即退出。
        executor.shutdown();
    }
}

运行结果:

数据=Real name

 

文章来源:http://www.2cto.com/kf/201411/351903.html

  • Java多线程编程中Future模式的详解_第2张图片
  • 大小: 28.2 KB
  • 查看图片附件

你可能感兴趣的:(Java多线程,Future模式)