漫谈并发编程：Future模型（Java、Clojure、Scala多语言角度分析）

客户端在调用的方法中，单独启用一个线程来完成真实数据的组织，这对调用客户端的main函数式封闭的；
。

/**
 * 数据的接口类
 * Created by Dante on 2017/4/8.
 */
public interface IData {
    public String getResult();
}

/**
 * Created by Dante on 2017/4/8.
 */
/*
 * 实现了一个快速返回RealData 的包装，但并非真实的返回结果。
 */
public class FutureData  implements IData {
    protected RealData realData=null; //FutureData是RealData的一个包装
    protected boolean isReady=false;
    public synchronized void setRealData(RealData realData)
    {
        if(isReady)
        {
            return;
        }
        this.realData=realData;
        isReady=true;
        notifyAll(); //当调用Future包装类的set方法时，线程RealData被唤醒，同个getResult()方法
    }

    @Override
    public synchronized String getResult() { //会等待RealData构造完成
        while(!isReady)
        {
            try{
                wait(); //一直等待，直到RealData被注入
            }catch (Exception e)
            {}
        }
        return realData.result; //RealData的真实实现
    }
}

/**
 * 真实的数据类，这是返回给用户的数据，数据的生成十分慢。
 * Created by Dante on 2017/4/8.
 */
public class RealData  implements IData {
    protected  final String result;
    public RealData(String para)
    {
        StringBuffer sb=new StringBuffer();
        //模拟一个很慢的构造过程
        for(int i=0;i<100;i++)
        {
            sb.append(para);
            try {
                Thread.sleep(100);//代替一个很慢的操作过程
            } catch (Exception e) {

            }
        }
        result=sb.toString();
    }
    public String getResult()
    {
        return result;
    }
}

/**
 * Server端，负责接收来自Client的数据请求，构造数据，并返回
 * Created by Dante on 2017/4/8.
 */
public class Server {
    public IData request(final String queryString) {
        final FutureData future = new FutureData();
        new Thread() //RealData构建很慢，放到一个单独的线程中进行
        {
            public void run() {
                RealData realData = new RealData(queryString);
                future.setRealData(realData);
                //调用future的set方法，直接return 并唤醒RealData线程进行数据构造};
            }
        }.start();
        return future;  //立即被返回
    }
}

/**
 * 主要负责调用server发起请求，并使用返回的数据
 * Created by Dante on 2017/4/8.
 */
public class Client {
    public static void main(String[] args) {
        System.out.println("建立和Server的连接！");
        Server server =new Server();
        //这里会立即返回结果，因为得到的是FutureData 而非RealData
        System.out.println("向Server发送数据请求！");
        IData data=server.request("name");
        System.out.println("请求完毕：" + data.toString() );
        try{
            //代表对其他业务的处理
            //在处理过程中，RealData被传剑，充分利用了等待时间
            //Thread.sleep(2000);
            System.out.println("开始处理其它业务！");
        }catch(Exception e)
        {}
        System.out.println("接收到真实的数据：\n"+data.getResult());
    }
}

/**
 * Created by Dante on 2017/4/8.
 */
import java.util.concurrent.*;

/**
 * 试验 Java 的 Future 用法
 */
public class FutureTest {

    public static class Task1 implements Callable<String> {
        @Override
        public String call() throws Exception {
            String tid = String.valueOf(Thread.currentThread().getId());
            System.out.printf("Thread#%s : in call\n", tid);
            Thread.sleep(111);
            return tid;
        }
    }

    public static class Task2 implements Callable<String> {
        @Override
        public String call() throws Exception {
            String tid = String.valueOf(Thread.currentThread().getId());
            System.out.printf("Thread#%s : in call\n", tid);
            Thread.sleep(1111);
            return tid;
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newCachedThreadPool();

        Future<String> restult1 = es.submit(new Task1());
        Future<String> restult2 = es.submit(new Task2());

        System.out.println(restult1.get());
        System.out.println(restult2.get());
    }

}

/**
  * Created by Dante on 2017/4/23.
  */
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

object FutureTest{

  def main(args: Array[String]) {
    val f = Future {
      println("Working on future task!")
      Thread.sleep(1000)
      1+1
    }

    println("Waiting for future task complete!")
    // 如果Future没有在Await规定的时间里返回,
    // 将抛出java.util.concurrent.TimeoutException
    val result = Await.result(f, 1 second)
    println("The future task result is " + result)
  }
}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Random, Success}
/**
  * Created by Dante on 2017/4/23.
  */
object NonBlockingFutureTest {
  def main(args: Array[String]) {

    println("starting calculation ...")
    val f = Future {
      Thread.sleep(Random.nextInt(500))
      42
    }

    println("before onComplete")
    f.onComplete{
      case Success(value) => println(s"Got the callback, meaning = $value")
      case Failure(e) => e.printStackTrace
    }
    // do the rest of your work
    println("A ...")
    Thread.sleep(100)
    println("B ....")
    Thread.sleep(100)
    println("C ....")
    Thread.sleep(100)
    println("D ....")
    Thread.sleep(100)
    println("E ....")
    Thread.sleep(100)
    Thread.sleep(2000)
  }
}

;; Clojure在语法层面上直接支持future，使用future关键字即可
user=> (def f (future (Thread/sleep 10000) (println "done") 100))
#'user/f
;;if you wait 10 seconds before dereferencing it you'll see "done"
;; When you dereference it you will block until the result is available.
user=> @f
done
100