文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

性能优化之Hystrix请求合并&自实现简化版本

2024-12-01 01:37

关注

有优点就有缺点，需要根据业务场景进行考量：

下面内容是对Hystrix请求合并及根据Hystrix请求合并原理自定义实现的简化版本。

Hystrix请求合并

什么是请求合并

Without Collapsing

without collapsing

With Collapsing

with collapsing

请求合并设计思路

design

Hystrix使用示例

示例采用Spring-Boot编写，下面代码拷贝到工程中可以直接运行。

添加依赖

下面是spring与hystrix集成的依赖pom。

pom


    org.springframework.cloud
    spring-cloud-starter-netflix-hystrix
    2.1.6.RELEASE

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@EnableHystrix
@SpringBootApplication
public class Application {
    public static void main(String[] args){
        SpringApplication.run(Application.class, args);
    }
}

使用示例

HystrixController

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

@RestController
public class HystrixController {
    @Resource
    private HystrixService hystrixService;

    @RequestMapping("/byid")
    public Long byId(Long id) throws InterruptedException, ExecutionException {
        Future<Long> future = hystrixService.byId(id);
        return future.get();
    }
}

HystrixService

import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.Future;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCollapser;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;

@Service
public class HystrixService {
    @HystrixCollapser(batchMethod="byIds",scope= com.netflix.hystrix.HystrixCollapser.Scope.GLOBAL,
            collapserProperties={
                @HystrixProperty(name="maxRequestsInBatch",value="10"),
                @HystrixProperty(name="timerDelayInMilliseconds",value="1000")
    })
    public Future<Long> byId(Long id){
        return null;
    }

    @HystrixCommand
    public List<Long> byIds(List<Long> ids){
        System.out.println(ids);
        return ids;
    }
}

测试类

发送请求进行验证。

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class HystrixTest {

    public static void main(String[] args) throws Exception{
        CloseableHttpClient httpClient = HttpClients.custom().setMaxConnPerRoute(100).build();
        String url = "http://localhost:8086/byid?id=";
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        int requestCount = 20;
        for(int i = 0;i < requestCount;i++){
            final int id = i;
            executorService.execute(new Runnable() {
                @Override
                public void run(){
                    try{
                        HttpGet httpGet = new HttpGet(url+ id);
                        HttpResponse response = httpClient.execute(httpGet);
                        System.out.println(response);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
        }

        Thread.sleep(1000*10);
        executorService.shutdown();
        httpClient.close();
    }
}

简化版本实现

由于Hystrix已不再维护，同时考虑到Hystrix使用RxJava的学习门槛，根据HystrixCollapser设计思路及常见业务功能需求实现了一个简化版本。

实现

RequestCollapserFactory

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class RequestCollapserFactory {
    private static RequestCollapserFactory factory;
    private static final int MAXBATCHSIZE = 20;
    private static final long DELAY = 1000L;
    private static final long PERIOD = 500L;
    private ConcurrentHashMap<String,RequestCollapser> collapsers;
    private ScheduledExecutorService executor;

    private RequestCollapserFactory(){
        collapsers = new ConcurrentHashMap<>();
        ThreadFactory threadFactory = new ThreadFactory() {
            final AtomicInteger counter = new AtomicInteger();
            @Override
            public Thread newThread(Runnable r){
                Thread thread = new Thread(r, "RequestCollapserTimer-" + counter.incrementAndGet());
                thread.setDaemon(true);
                return thread;
            }
        };
        executor = new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), threadFactory);
    }

    public static RequestCollapserFactory getInstance(){
        if(factory != null){
            return factory;
        }
        synchronized (RequestCollapserFactory.class){
            if(factory != null){
                return factory;
            }
            factory = new RequestCollapserFactory();
        }
        return factory;
    }

    public RequestCollapser getRequestCollapser(String key,RequestBatch requestBatch){
        return getRequestCollapser(key,requestBatch,MAXBATCHSIZE,DELAY,PERIOD);
    }
    public RequestCollapser getRequestCollapser(String key,RequestBatch requestBatch,int maxBatchSize){
        return getRequestCollapser(key,requestBatch,maxBatchSize,DELAY,PERIOD);
    }
    public RequestCollapser getRequestCollapser(String key,RequestBatch requestBatch,int maxBatchSize,long delay, long period){
        RequestCollapser collapser = collapsers.get(key);
        if(collapser != null){
            return collapser;
        }

        synchronized (collapsers){
            collapser = collapsers.get(key);
            if(collapser != null){
                return collapser;
            }
            collapser = new RequestCollapser(requestBatch,maxBatchSize,delay,period,executor);
            collapsers.put(key,collapser);
            return collapser;
        }
    }
}

RequestCollapser

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

public class RequestCollapser {
    private int maxBatchSize;
    private long delay;
    private long period;
    private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue();
    private ScheduledExecutorService executor;
    private RequestBatch requestBatch;
    private AtomicBoolean timerscheduled = new AtomicBoolean();
    protected RequestCollapser(RequestBatch requestBatch,int maxBatchSize,long delay,long period,ScheduledExecutorService executor){
        if(requestBatch == null){
            throw new IllegalArgumentException("requestBatch can not be null");
        }
        this.maxBatchSize = maxBatchSize;
        this.delay = delay;
        this.period = period;
        this.executor = executor;
        this.requestBatch = requestBatch;
    }

    public List<Object> submitRequest(Object obj,boolean ifFullThenBatchExecute){
        if(timerscheduled.compareAndSet(false,true)){
            this.startSchedule();
        }
        List<Object> objectList = null;
        synchronized (queue){
            if(obj instanceof Collection){
                queue.addAll((Collection)obj);
            }else {
                queue.offer(obj);
            }

            if(queue.size() >= this.maxBatchSize){
                objectList = new LinkedList<>();
                queue.drainTo(objectList);
            }
        }

        if(!ifFullThenBatchExecute){
            return objectList;
        }

        this.doBatch(objectList);
        return null;
    }

    private boolean doBatch(List<Object> objectList){
        if(objectList == null){
            return true;
        }
        try{
            return requestBatch.batch(objectList);
        }catch (Throwable t){
            t.printStackTrace();
        }
        return false;
    }

    private void startSchedule(){
        Runnable r = new Runnable() {
            @Override
            public void run(){
                List<Object> objectList = null;
                synchronized (queue){
                    if(queue.size() > 0) {
                        objectList = new LinkedList<>();
                        queue.drainTo(objectList);
                    }
                }
                doBatch(objectList);
            }
        };

        this.executor.scheduleAtFixedRate(r,this.delay,this.period, TimeUnit.MILLISECONDS);
    }
}

RequestBatch

import java.util.List;

public interface RequestBatch {
    boolean batch(List objectList);
}
验证测试
RequestCollapserTest
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class RequestCollapserTest {
    private static AtomicInteger counter = new AtomicInteger();
    private static long delay = 1;
    private static long period = 1;
    private static int maxBatchSize = 20;
    private static int requestCount = 50000;
    private static RequestCollapserFactory factory = RequestCollapserFactory.getInstance();
    private static RequestBatch requestBatch = new RequestBatch() {
        @Override
        public boolean batch(List<Object> objectList){
            int size = objectList.size();
            counter.addAndGet(size);
            System.out.println(counter + ":::::" + size + ":::::" + objectList);
            return true;
        }
    };

    public static void main(String[] args) throws Exception{
        //sync();
        async();
    }

    public static void async() throws Exception{
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        CountDownLatch countDownLatch = new CountDownLatch(requestCount);
        for(int i = 0;i < requestCount;i++){
            final int id = i;
            executorService.execute(new Runnable() {
                @Override
                public void run(){
                    try{
                        RequestCollapser requestCollapser =
                                factory.getRequestCollapser("1",requestBatch,maxBatchSize,delay,period);
                        requestCollapser.submitRequest(id,true);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    countDownLatch.countDown();
                }
            });
        }

        executorService.shutdown();
        countDownLatch.await();
        Thread.sleep(1000);
        System.out.println(counter.get());
    }

    public static void sync() throws Exception{
        for(int i = 0;i < requestCount;i++){
            final int id = i;
            RequestCollapser requestCollapser =
                    factory.getRequestCollapser("1",requestBatch,maxBatchSize,delay,period);
            requestCollapser.submitRequest(id,true);
        }
        Thread.sleep(1000);
        System.out.println(counter.get());
    }
}

来源：今日头条内容投诉
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
软考中级精品资料免费领 
  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 资料下载
  • 历年真题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
     难度      813人已做 
     查看 
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
     难度      354人已做 
     查看 
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
     难度      318人已做 
     查看 
  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
     难度      435人已做 
     查看 
  • 2024年上半年系统架构设计师考试综合知识真题
     难度      224人已做 
     查看 
相关文章
发现更多好内容
猜你喜欢
AI推送时光机
性能优化之Hystrix请求合并&自实现简化版本
后端开发HystrixQPS2024-12-01
 位置：首页-资讯-后端开发
 咦！没有更多了？去看看其它编程学习网 内容吧 
首页课程
资料下载问答资讯