public class Singleton {
 private Singleton() {
 System.out.println("Singleton is create");
 }
 private static Singleton instance = new Singleton();
 public static Singleton getInstance() {
 return instance;
 }
}

public class Singleton {
 public static int STATUS=1; 
 private Singleton() {
 System.out.println("Singleton is create");
 }
 private static Singleton instance = new Singleton();
 public static Singleton getInstance() {
 return instance;
 }
}

public class Singleton {
 private Singleton() {
 System.out.println("Singleton is create");
 }
 private static Singleton instance = null;
 public static synchronized Singleton getInstance() {
 if (instance == null)
 instance = new Singleton();
 return instance;
 }
}

public class StaticSingleton {
 private StaticSingleton(){ 
 System.out.println("StaticSingleton is create");
 }
 private static class SingletonHolder {
 private static StaticSingleton instance = new StaticSingleton();
 }
 public static StaticSingleton getInstance() {
 return SingletonHolder.instance;
 }
}

public final class Product {
 // 确保无子类
 private final String no;
 // 私有属性，不会被其他对象获取
 private final String name;
 // final保证属性不会被2次赋值
 private final double price;

 public Product(String no, String name, double price) {
 // 在创建对象时，必须指定数据
 super();
 // 因为创建之后，无法进行修改
 this.no = no;
 this.name = name;
 this.price = price;
 }

 public String getNo() {
 return no;
 }

 public String getName() {
 return name;
 }

 public double getPrice() {
 return price;
 }

}

public interface Data { 
 public String getResult (); 
}
public class FutureData implements Data { 
 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(); //RealData已经被注入，通知getResult() 
 } 
 public synchronized String getResult()//会等待RealData构造完成 
 { 
 while (!isReady) { 
 try {  
 wait(); //一直等待，知道RealData被注入 
 } catch (InterruptedException e) { 
 } 
 } 
 return realdata.result; //由RealData实现 
 } 
}
public class RealData implements Data {
 protected final String result;
 public RealData(String para) {
 // RealData的构造可能很慢，需要用户等待很久，这里使用sleep模拟
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < 10; i++) {
 sb.append(para);
 try {
 // 这里使用sleep，代替一个很慢的操作过程
 Thread.sleep(100);
 } catch (InterruptedException e) {
 }
 }
 result = sb.toString();
 }
 public String getResult() {
 return result;
 }
}
public class Client { 
 public Data request(final String queryStr) { 
 final FutureData future = new FutureData(); 
 new Thread() {
 public void run() 
 {
 // RealData的构建很慢， 
 //所以在单独的线程中进行 
 RealData realdata = new RealData(queryStr);  
 future.setRealData(realdata); 
 }    
 }.start(); 
 return future; // FutureData会被立即返回 
 } 
}
public static void main(String[] args) {
 Client client = new Client();
 // 这里会立即返回，因为得到的是FutureData而不是RealData
 Data data = client.request("name");
 System.out.println("请求完毕");
 try {
 // 这里可以用一个sleep代替了对其他业务逻辑的处理
 // 在处理这些业务逻辑的过程中，RealData被创建，从而充分利用了等待时间
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 }
 // 使用真实的数据
 System.out.println("数据 = " + data.getResult());
 }

import java.util.concurrent.Callable;

public class RealData implements Callable<String> {
 private String para;

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

 @Override
 public String call() throws Exception {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < 10; i++) {
 sb.append(para);
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {

 }
 }
 return sb.toString();
 }
}

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

public class FutureMain {
 public static void main(String[] args) throws InterruptedException,
 ExecutionException {
 // 构造FutureTask
 FutureTask<String> future = new FutureTask<String>(new RealData("a"));
 ExecutorService executor = Executors.newFixedThreadPool(1);
 // 执行FutureTask，相当于上例中的 client.request("a") 发送请求
 // 在这里开启线程进行RealData的call()执行
 executor.submit(future);
 System.out.println("请求完毕");
 try {
 // 这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 }
 // 相当于data.getResult ()，取得call()方法的返回值
 // 如果此时call()方法没有执行完成，则依然会等待
 System.out.println("数据 = " + future.get());
 }
}

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

public class FutureMain2 {
 public static void main(String[] args) throws InterruptedException,
 ExecutionException {
 ExecutorService executor = Executors.newFixedThreadPool(1);
 // 执行FutureTask，相当于上例中的 client.request("a") 发送请求
 // 在这里开启线程进行RealData的call()执行
 Future<String> future = executor.submit(new RealData("a"));
 System.out.println("请求完毕");
 try {
 // 这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 }
 // 相当于data.getResult ()，取得call()方法的返回值
 // 如果此时call()方法没有执行完成，则依然会等待
 System.out.println("数据 = " + future.get());
 }
}