package callableTest;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class CallableIndicator{
    private String name;
    private Double result;
    static public final int TIME = 3000;
    public CallableIndicator(String name, Double result){
        this.name = name;
        this.result = result;
    }
    
    public Double getResult(){
        return this.result;
    }
    
    public String getName(){
        return this.name;
    }
}

public class CallableTest {
     private static final int POOL_SIZE = 2;
     
        static class CalcThread implements Callable<CallableIndicator> {
            
            private String name;
            private List<Double> dataList = new ArrayList<>();
     
            public CalcThread(String name) {
                for(int i = 0; i < 10000; ++i) {
                    dataList.add(Math.random());
                }
                this.name = name;
                System.out.println("In CalcThread constructor, thread id: " + 
                Thread.currentThread().getId());
            }
     
            @Override
            public CallableIndicator call() throws Exception {
                
                double total = 0;
                for(Double d : dataList) {
                    total += d;
                }
                
                System.out.println("In CalcThread @Override call(), thread id: " + 
                        Thread.currentThread().getId());
                Thread.sleep(CallableIndicator.TIME);
                return new CallableIndicator(this.name, total / dataList.size());
            }
     
        }
     
        public static void printThread(){
            System.out.println("In main Thread? " + Thread.currentThread().getId());
        }
        
        public static void main(String[] args) {
            long start = System.currentTimeMillis();
            List<Future<CallableIndicator>> fList = new ArrayList<>();
            ExecutorService es = Executors.newFixedThreadPool(POOL_SIZE);
            
            printThread();
            System.out.println("Ready to submit new thread...");
            for(int i = 0; i < POOL_SIZE; ++i) {
                fList.add(es.submit(new CalcThread("Jerry Thread: " + i)));
            }
     
            for(Future<CallableIndicator> f : fList) {
                try {
                    /*
                     * 注意这个get是异步操作：The result can only be retrieved using method get when the computation has completed, blocking if necessary until it is ready. 
                     */
                    System.out.println("Thread name: " + f.get().getName() + " result: " +  f.get().getResult());
                    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("duration: " + ( end - start));
            es.shutdown();
        }
}