Asynchronous Base Pattern

Executor

import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;

@Slf4j
public class Executor {

    private final ConcurrentLinkedQueue<FutureTask> futureTasks = new ConcurrentLinkedQueue<>();

    private final HashMap<String, Worker> hashMap = new HashMap<>();

    private final int threads;

    public Executor(int threads) {
        this.threads = threads;
        for (int i = 0; i < threads; i++) {
            Worker worker = new Worker(this);
            hashMap.put("worker-" + i, worker);
            worker.start();
        }
    }

    public FutureResult submit(Callable callable) {
        FutureResult futureResult = new FutureResult();
        FutureTask futureTask = new FutureTask(futureResult, callable);
        futureTasks.add(futureTask);
        return futureResult;
    }

    // 线程安全问题：poll()可能为空
    public void execute() {
        while (true) {
            // 增加循环间时间间隔
            try {
                while (!futureTasks.isEmpty()) {
                    futureTasks.poll().run();
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                log.error("Executor execute error", e);
            } catch (NullPointerException ignored) {
            }
        }
    }

    public static void main(String[] args) {
        Executor executor = new Executor(100);
        for (int i = 0; i < 10000000; i++) {
            int finalI = i;
            FutureResult futureResult = executor.submit(() -> {
                Double random = Math.random();
                random = random * random * random * random * random * random;
                System.out.println(finalI +"-------------"+random);
                return random;
            });
        }

    }



}

 Worker

public class Worker extends Thread {

    private Executor executor;

    public Worker(Executor executor) {
        this.executor = executor;
    }

    @Override
    public void run() {
        executor.execute();
    }
}

FutureTask

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;

@Slf4j
public class FutureTask {
    private final FutureResult futureResult;
    private final Callable callable;

    private Boolean exceptionFlag = false;

    public FutureTask(FutureResult futureResult, Callable callable) {
        this.futureResult = futureResult;
        this.callable = callable;
    }

    public FutureResult getFutureResult() {
        return futureResult;
    }


    // 执行Callable call() 设置FutureResult value属性值
    public FutureResult run() {
        try {
            Object call = callable.call();
            futureResult.setValue(call);
        } catch (Exception e) {
            exceptionFlag = true;
            log.error("FutureTask run error",e);
        }
        return futureResult;
    }


}

FutureResult

public class FutureResult  {
    private Object value;


    public FutureResult() {
    }


    public Object getValue() {
        if (!isDone()) {
            System.out.println("FutureTask 未完成");
            return null;
        } else {
            return value;
        }
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public boolean isDone() {
        return value != null;
    }


}