使用FutureTask和CompletableFuture对并行任务进行优化

不知码农

已于 2023-08-07 22:49:47 修改

阅读量186

点赞数

文章标签： java

于 2023-08-06 12:41:16 首次发布

本文链接：https://blog.csdn.net/m0_66328098/article/details/132129719

版权

一、使用FutureTask

package com.itheima.security.springboot.controller;

import com.itheima.security.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.Callable;

@RestController
public class UserController {

    @Autowired
    private UserService UserServiceImpl;

    @RequestMapping("/getUserInfo")
    public Object getUserInfo(@RequestParam("userId") long userId) {
        return UserServiceImpl.getUserInfo(userId);
    }

    @RequestMapping("/getUserInfoCurr")
    public Object getUserInfoCurr(@RequestParam("userId") long userId) {
        return UserServiceImpl.getUserInfoOptimize(userId);
    }

    /**
     * @Title: todo Spring Servlet3.0以后支持使用Callable的方式提供对异步的支持，避免主线程
     * 阻塞，减少上下文切换，提升系统吞吐量
     * @Description: TODO
     * @throws
     * @Author: Vector
     * @DateTime:
     */
    @RequestMapping("/getUserInfoSync")
    public Callable<Object> getUserInfoSync(@RequestParam("userId") long userId) {
        Callable<Object> callable = new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                return UserServiceImpl.getUserInfoOptimize(userId);
            }
        };
        return callable;
    }
}

package com.itheima.security.springboot.service;

public interface UserService {
    Object getUserInfo(long userId);

    Object getUserInfoOptimize(long userId);
}

package com.itheima.security.springboot.service.impl;

import com.itheima.security.springboot.service.UserService;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.FutureTask;

@Service
public class UserServiceImpl implements UserService {

    @Resource(name = "myRestTemplate")
    private RestTemplate restTemplate;

    @Override
    public Object getUserInfo(long userId) {
        HashMap<Object, Object> reqMap = new HashMap<>();
        //1.模拟调用微服务-获取用户信息
        ResponseEntity<Map> responseEntity1 = restTemplate.postForEntity("www.baidu.com", reqMap, Map.class);

        //2.模拟调用微服务-查询用余额信息
        ResponseEntity<Map> responseEntity2 = restTemplate.postForEntity("www.baidu.com", reqMap, Map.class);
        //3.模拟调用微服务-获取积分信息
        ResponseEntity<Map> responseEntity3 = restTemplate.postForEntity("www.baidu.com", reqMap, Map.class);
        return null;
    }

    /**
     * @throws
     * @Title: 使用多线程进行优化
     * @Description: TODO
     * @Author: Vector
     * @DateTime:
     */
    @Override
    public Object getUserInfoOptimize(long userId) {
        HashMap<Object, Object> req = new HashMap<>();
        //1.模拟调用微服务-获取用户信息
        Map<String, Object> userInfoMap = null;
        try {
            FutureTask<Map<String, Object>> future1 = new FutureTask(() -> {
                ResponseEntity<Map> responseEntity1 = restTemplate.postForEntity("www.baidu.com", req, Map.class);
                return responseEntity1.getBody();
            });
            new Thread(future1).start();

            userInfoMap = future1.get(); //todo 优化点：get是一个阻塞方法
        } catch (Exception e) {
            e.printStackTrace();
        }


        //2.模拟调用微服务-查询用余额信息
        Map<String, Object> balanceMap = null;
        try {
            FutureTask<Map<String, Object>> future2 = new FutureTask(() -> {
                ResponseEntity<Map> responseEntity2 = restTemplate.postForEntity("www.baidu2.com", req, Map.class);
                return responseEntity2.getBody();
            });
            new Thread(future2).start();

            balanceMap = future2.get();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //3.模拟调用微服务-获取积分信息
        Map<String, Object> integralMap = null;
        try {
            FutureTask<Map<String, Object>> future3 = new FutureTask(() -> {
                ResponseEntity<Map> responseEntity3 = restTemplate.postForEntity("www.baidu3.com", req, Map.class);
                return responseEntity3.getBody();
            });
            new Thread(future3).start();

            integralMap = future3.get();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

package com.itheima.security.springboot.config;

import okhttp3.OkHttpClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.TimeUnit;

@ComponentScan
@Configuration
public class RestTemplateConfig {

    @Bean(name = "myRestTemplate")
    public RestTemplate RestTemplate() {
        RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory());
        return restTemplate;
    }

    /**
     * 使用OkHttpClient作为底层客户端
     *
     * @return
     */
    private ClientHttpRequestFactory getClientHttpRequestFactory() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
        return new OkHttp3ClientHttpRequestFactory(okHttpClient);
    }

}

二、使用CompletableFuture+ScheduledExecutorService

package com.itheima.security.springboot.controller;

import com.itheima.security.springboot.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class OrderController {

    @Autowired
    private OrderService OrderServiceImpl;

    @RequestMapping("/queryOrderInfo")
    public Map<String, Object> queryOrderInfo(@RequestParam("orderId") String orderId) {
        return OrderServiceImpl.queryOrderInfo(orderId);
    }

    @RequestMapping("/queryOrderBatch")
    public Map<String, Object> queryOrderBatch(@RequestParam("orderId") String orderId) {
        Map<String, Object> resultMap = null;
        try {
            resultMap = OrderServiceImpl.queryOrderBatch(orderId);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }
}

package com.itheima.security.springboot.service;

import java.util.Map;

public interface OrderService {

    Map<String, Object> queryOrderInfo(String orderId);

    Map<String, Object> queryOrderBatch(String orderId) throws Exception;
}


package com.itheima.security.springboot.service.impl;

import cn.hutool.core.lang.Snowflake;
import com.itheima.security.springboot.service.OrderService;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

@Service
public class OrderServiceImpl implements OrderService {

    private static final Logger log = LoggerFactory.getLogger(OrderServiceImpl.class);

    @Resource(name = "myRestTemplate")
    private RestTemplate restTemplate;
    @Autowired
    private RemoteService remoteService;

    //阻塞队列：线程安全  性能考虑：对于删除和添加效率最高；查询效率低，该场景不考虑查询
    private static final LinkedBlockingQueue<Request> queue = new LinkedBlockingQueue<>();

    /**
     * @throws
     * @Title: 查询订单：没有优化之前
     * @Description: TODO
     * @Author: Vector
     * @DateTime:
     */
    @Override
    public Map<String, Object> queryOrderInfo(String orderId) {
        System.out.println("接口调用");
        HashMap<Object, Object> reqMap = new HashMap<>();
        reqMap.put("orderId", orderId);
        //1.模拟调用微服务-获取订单信息
        ResponseEntity<Map> responseEntity1 = restTemplate.postForEntity("www.baidu.com", reqMap, Map.class);
        return responseEntity1.getBody();
    }

    /**
     * @throws
     * @Title: 查询订单：后端（微服务访问）采用批量的方式处理，对于APP和浏览器 不需要任何改变
     * @Description: TODO
     * @Author: Vector
     * @DateTime:
     */
    @Override
    public Map<String, Object> queryOrderBatch(String orderId) throws Exception {

        //确保唯一性的ID
        Snowflake snowflake = new Snowflake(27, 16, true);
        String serialNo = snowflake.nextId() + "";

        //CompletableFuture:监听结果（线程），相当于FutureTask,批量
        CompletableFuture<Map<String, Object>> future = new CompletableFuture<>();
        //todo 绑定业务线程 serialNo-orderId
        Request request = new Request();
        request.setSerialNo(serialNo);
        request.setFuture(future);
        request.setOrderId(orderId);
        queue.add(request); //把数据放到队列中

        return future.get(); //todo 阻塞的等待结果；如果拿到结果，类似FutureTask.get();
    }


    @Data
    static class Request {
        //todo 绑定业务线程 serialNo-orderId
        private String serialNo;
        private CompletableFuture<Map<String, Object>> future;
        private String orderId; //前端上送的订单号，可能会重复
    }

    /**
     * @throws
     * @Title: 项目启动前初始化定时任务调度线程池
     * @Description: TODO
     * @Author: Vector
     * @DateTime:
     */
    @PostConstruct
    public void initThreadPool() {
        //定时任务的线程池，每隔10毫秒运行一次
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(1);

        threadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {

                int size = queue.size(); //队列中请求的数量
                if (0 == size) { //没有请求，直接返回
                    return;
                }

                //根据接口来封装批量参数，两个List，一个组装请求，另一个要进行返回值的对应
                List<Map<String, String>> params = new ArrayList<>(); //请求参数
                List<Request> requests = new ArrayList<>(); //进行接口的响应映射

                for (int i = 0; i < size; i++) {
                    Request request = queue.poll();
                    HashMap<String, String> param = new HashMap<>();
                    param.put("serialNo", request.getSerialNo());
                    param.put("orderId", request.getOrderId());

                    params.add(param); //将请求放到params list中

                    requests.add(request);
                }

                log.info("批量处理的数据量:{}条", size);

                //开始批量调用接口
                List<Map<String, Object>> responses = remoteService.queryOrderInfoIdBatch(params);
                // todo 将批量结果映射到对应的对应的线程（通过serialNo来关联）
                for (Request request : requests) {  //todo 简单粗暴，利用二分查找、数据结构等来优化
                    String serialNo = request.getSerialNo();
                    for (Map<String, Object> res : responses) {
                        //todo 通过erialNo来关联对应的线程
                        if (serialNo.equals(res.get("serialNo"))) {
                            //todo 与其对应的get方法将其唤醒（future.get()）
                            request.getFuture().complete(res);
                            break;
                        }
                    }
                }


            }
        }, 100, 10, TimeUnit.MILLISECONDS);


    }
}

package com.itheima.security.springboot.config;

import okhttp3.OkHttpClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.TimeUnit;

@ComponentScan
@Configuration
public class RestTemplateConfig {

    @Bean(name = "myRestTemplate")
    public RestTemplate RestTemplate() {
        RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory());
        return restTemplate;
    }

    /**
     * 使用OkHttpClient作为底层客户端
     *
     * @return
     */
    private ClientHttpRequestFactory getClientHttpRequestFactory() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
        return new OkHttp3ClientHttpRequestFactory(okHttpClient);
    }

}

package com.itheima.security.springboot.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Title: 模拟批量调用远程接口
 * @Description: TODO
 * @Params:
 * @return
 * @throws
 * @Author: Vector
 * @DateTime:
 */

@Service
public class RemoteService {

    private static final Logger log = LoggerFactory.getLogger(RemoteService.class);

    public List<Map<String, Object>> queryOrderInfoIdBatch(List<Map<String, String>> params) {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        List<Map<String, Object>> resultMap = new ArrayList<>();

        return resultMap;
    }
}