/**
     * 這里會阻塞tomcat的線程
     */
    @GetMapping("getAllEgOne")
    public Map<String, Object> getAllEgOne() throws ExecutionException, InterruptedException {
        FutureTask<String> stringFutureTaskOne = new FutureTask<>(asyncService::getOne);
        FutureTask<String> stringFutureTaskTwo = new FutureTask<>(asyncService::getTwo);
        FutureTask<String> stringFutureTaskThree = new FutureTask<>(asyncService::getThree);
        new Thread(stringFutureTaskOne).start();
        new Thread(stringFutureTaskTwo).start();
        new Thread(stringFutureTaskThree).start();
        Map<String, Object> result = new HashMap<>();
        result.put("one", stringFutureTaskOne.get());
        result.put("two", stringFutureTaskTwo.get());
        result.put("three", stringFutureTaskThree.get());
        return result;
    }

 /**
     * 這里不會阻塞tomcat的線程
     */
    @GetMapping("getAllEgTwo")
    public Callable<Map<String, Object>> getAllEgTwo() {
        return () -> {
            FutureTask<String> stringFutureTaskOne = new FutureTask<>(asyncService::getOne);
            FutureTask<String> stringFutureTaskTwo = new FutureTask<>(asyncService::getTwo);
            FutureTask<String> stringFutureTaskThree = new FutureTask<>(asyncService::getThree);
            new Thread(stringFutureTaskOne).start();
            new Thread(stringFutureTaskTwo).start();
            new Thread(stringFutureTaskThree).start();
            Map<String, Object> result = new HashMap<>(3);
            result.put("one", stringFutureTaskOne.get());
            result.put("two", stringFutureTaskTwo.get());
            result.put("three", stringFutureTaskThree.get());
            return result;
        };
    }

import com.example.demo.conf.SnowFlake;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
/**
 * @author liwenchao
 */
@RestController
@RequestMapping("async")
@Slf4j
public class AsyncController {
    @Autowired
    private AsyncService asyncService;
    private final SnowFlake worker = new SnowFlake(1, 1, 1);
    private final LinkedBlockingQueue<RequestBody<Long, UserInfo>> queue = new LinkedBlockingQueue<>();
    @PostConstruct
    public void doWork() {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(() -> {
            //每次運行的時候 去拿MQ中的數據量
            int size = queue.size();
            if (size == 0) {
                return;
            }
            log.info("批量獲取任務：{}-{}", Thread.currentThread().getName(), size);
            //多次請求收集到一起一塊去批量請求下面的需要的數據
            List<Long> requestBodyList = new ArrayList<>();
            List<RequestBody<Long, UserInfo>> requestBodies = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                RequestBody<Long, UserInfo> requestBody = queue.poll();
                requestBodies.add(requestBody);
                Long requestParam = requestBody.getRequestParam();
                requestBodyList.add(requestParam);
            }
            List<UserInfo> fourBatch;
            try {
                fourBatch = asyncService.getFourBatch(requestBodyList);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (CollectionUtils.isEmpty(fourBatch)) {
                return;
            }
            for (UserInfo x : fourBatch) {
                for (RequestBody<Long, UserInfo> y : requestBodies) {
                    if (x.getId().equals(y.getRequestParam())) {
                        y.getResult().complete(x);
                        break;
                    }
                }
            }
        }, 1000L, 50L, TimeUnit.MILLISECONDS);
    }
    /**
     * ● 插入
     * 1.add(e)：當阻塞隊列滿時，再往隊列里add插入元素會拋IllegalStateException:Queue full
     * 2.offer(e)：插入方法，成功true失敗返回false
     * 3.put(e)：當阻塞隊列滿時，生產者線程繼續(xù)往隊列里添加元素，隊列會一直阻塞生產者線程。直到put數據or響應中斷退出
     * 4.offer(e,time,unit)：當阻塞隊列滿的時候，隊列會阻塞生產者線程一定時間，超過限時后生產者線程會退出。
     * <p>
     * ● 移除
     * 1.remove():當隊列為空的時候，再往隊列里remove移除元素會拋NoSuchElementException
     * 2.poll():移除方法，成功返回出隊列的元素，隊列里沒有就返回null。
     * 3.take():當隊列為空消費者線程試圖從隊列里take元素，隊列會一直阻塞消費者線程知道隊列可用
     * 4.poll(time,unit)：當隊列為空的時候，會阻塞一段時間超時后消費者線程退出。
     * <p>
     * ● 檢查
     * 1.element()：當隊列為空時直接拋出異常
     * 2.peek()：當隊列為空時阻塞
     * <p>
     * 這里不會阻塞tomcat的線程
     */
    @GetMapping("getAllEgFour")
    public UserInfo getAllEgFour(Long userId) throws ExecutionException, InterruptedException {
        if (userId == null) {
            userId = worker.nextId();
        }
        log.info("開始獲取數據: {}: {}", Thread.currentThread().getName(), userId);
        RequestBody<Long, UserInfo> objectObjectRequestBody = new RequestBody<>();
        CompletableFuture<UserInfo> completableFuture = new CompletableFuture<>();
        objectObjectRequestBody.setRequestParam(userId);
        objectObjectRequestBody.setResult(completableFuture);
        queue.add(objectObjectRequestBody);
        UserInfo userInfo = completableFuture.get();
        log.info("完成獲取數據: {}: {}", Thread.currentThread().getName(), userInfo);
        return userInfo;
    }
}