public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

public class FutureTask<V> implements RunnableFuture<V> {

	// 最初始的狀態(tài)是new 新建狀態(tài)
	private volatile int state;
    private static final int NEW          = 0; // 新建狀態(tài)
    private static final int COMPLETING   = 1; // 完成中
    private static final int NORMAL       = 2; // 正常執(zhí)行完
    private static final int EXCEPTIONAL  = 3; // 異常
    private static final int CANCELLED    = 4; // 取消
    private static final int INTERRUPTING = 5; // 正在中斷
    private static final int INTERRUPTED  = 6; // 已中斷

	public V get() throws InterruptedException, ExecutionException {
	    int s = state;
	    // 任務還在執(zhí)行中
	    if (s <= COMPLETING)
	        s = awaitDone(false, 0L);
	    return report(s);
	}
	
	private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
        	// 線程被中斷，從等待隊列中移除等待節(jié)點WaitNode，拋出中斷異常
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            // 任務已執(zhí)行完畢或取消
            if (s > COMPLETING) {
            	// 如果已有等待節(jié)點WaitNode，將線程置空
                if (q != null)
                    q.thread = null;
                return s;
            }
            // 任務正在執(zhí)行，讓出時間片
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            // 還未構造等待節(jié)點，則new一個新的等待節(jié)點
            else if (q == null)
                q = new WaitNode();
            // 未入隊列，CAS嘗試入隊
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            // 如果有超時時間參數(shù)
            else if (timed) {
            	// 計算超時時間
                nanos = deadline - System.nanoTime();
                // 如果超時，則從等待隊列中移除等待節(jié)點WaitNode，返回當前狀態(tài)state
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                // 阻塞隊列nanos毫秒
                LockSupport.parkNanos(this, nanos);
            }
            else
            	// 阻塞隊列
                LockSupport.park(this);
        }
    }
    
	private V report(int s) throws ExecutionException {
		// 獲取outcome中記錄的返回結果
        Object x = outcome;
        // 如果執(zhí)行完畢，返回結果
        if (s == NORMAL)
            return (V)x;
            // 如果大于等于取消狀態(tài)，則拋出異常
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }
}

@Async("async-executor")
public void readXls(String filePath, String filename) {
    try {
    	// 此代碼為簡化關鍵性代碼
        List<Future<Integer>> futureList = new ArrayList<>();
        for (int time = 0; time < times; time++) {
            Future<Integer> sumFuture = readExcelDataAsyncFutureService.readXlsCacheAsync();
            futureList.add(sumFuture);
        }
    }catch (Exception e){
        logger.error("readXlsCacheAsync---插入數(shù)據(jù)異常：",e);
    }
}

@Async("async-executor")
public Future<Integer> readXlsCacheAsync() {
    try {
        // 此代碼為簡化關鍵性代碼
        return new AsyncResult<>(sum);
    }catch (Exception e){
        return new AsyncResult<>(0);
    }
}

public static boolean getFutureResult(List<Future<Integer>> futureList, int excelRow){
    int[] futureSumArr = new int[futureList.size()];
    for (int i = 0;i<futureList.size();i++) {
        try {
            Future<Integer> future = futureList.get(i);
            while (true) {
                if (future.isDone() && !future.isCancelled()) {
                    Integer futureSum = future.get();
                    logger.info("獲取Future返回值成功"+"----Future:" + future
                            + ",Result:" + futureSum);
                    futureSumArr[i] += futureSum;
                    break;
                } else {
                    logger.info("Future正在執(zhí)行---獲取Future返回值中---等待3秒");
                    Thread.sleep(3000);
                }
            }
        } catch (Exception e) {
            logger.error("獲取Future返回值異常: ", e);
        }
    }
    
    boolean insertFlag = getInsertSum(futureSumArr, excelRow);
    logger.info("獲取所有異步線程Future的返回值成功，Excel插入結果="+insertFlag);
    return insertFlag;
}

public static Future<Boolean> getFutureResultThreadFuture(List<Future<Integer>> futureList, int excelRow) {
    ExecutorService service = Executors.newSingleThreadExecutor();
    final boolean[] insertFlag = {false};
    service.execute(new Runnable() {
        public void run() {
            try {
                insertFlag[0] = getFutureResult(futureList, excelRow);
            } catch (Exception e) {
                logger.error("新線程+Future獲取Future返回值異常: ", e);
                insertFlag[0] = false;
            }
        }
    });
    service.shutdown();
    return new AsyncResult<>(insertFlag[0]);
}