异步编程

import java.util.concurrent.CountDownLatch;

public class MyResult {
    int id;
    int result =0;

    CountDownLatch countDownLatch = null;
    public MyResult(int id) {
        this.id = id;
        countDownLatch = new CountDownLatch(1);
    }

    public void setResult(int result){
        this.result = result;
        countDownLatch.countDown();
    }

    public Integer getResult(){
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }

}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

public class MyPromise {
    public  static ExecutorService executorService = Executors.newFixedThreadPool(5);
    public static Map<Integer,MyResult> map = new HashMap<>();
    static {
        for(int i=0; i<10; i++){
            map.put(i,new MyResult(i));
        }
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        List<Future<Integer>> futureList = new ArrayList<>();
        for(int i=0;i<10; i++){
            final int finalI = i;
            Future<Integer> future = executorService.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    Thread.sleep(500);
                    map.get(finalI).setResult(1);
                    return 1;
                }
            });
//            futureList.add(future);

        }
        int sum = 0;
        for(int i=0; i<10; i++){
//            futureList.get(i).get();
            Integer result = map.get(i).getResult();
            sum = sum + result;
        }
        System.out.println(sum);
        System.out.println(System.currentTimeMillis() - start);

        executorService.shutdown();
    }
}

import java.util.concurrent.*;

public class MyPromise2 {
    public static ExecutorService executorService = Executors.newFixedThreadPool(5);
    public static ExecutorCompletionService<Integer> executorCompletionService = new ExecutorCompletionService(executorService);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        for(int i=0;i<10; i++){
            executorCompletionService.submit(new Callable() {
                @Override
                public Object call() throws Exception {
                    Thread.sleep(500);
                    return 1;
                }
            });
        }
        int sum = 0;
        for(int i=0; i<10; i++){
            Integer result = executorCompletionService.take().get();
            sum += result;
        }
        System.out.println(sum);
        System.out.println(System.currentTimeMillis() - start);
        executorService.shutdown();
    }
}