Hystrix服务容错之线程池隔离

古城微笑少年丶 2023-01-04 14:37 156阅读 0赞

**如果没有线程池隔离，所有的接口都运行在一个ThreadPool中，当某一个接口压力过大或者出现故障时，会导致资源耗尽从而影响到其他接口而引发雪崩效应**

下面直接介绍如何开启线程池隔离

需要的依赖

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>

启动类开启Hystrix

package com.qiangqiang;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.hystrix.EnableHystrix;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    @SpringBootApplication
    @EnableFeignClients
    @EnableHystrix
    public class SpringCloudOrderServerThreadPoolApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringCloudOrderServerThreadPoolApplication.class, args);
        }
    
    }

远程调用实现类，注意下兜底的方法，要和被兜底的方法保持相同的参数，不然报错

fallback method wasn’t found: undertake

要不就注解里别写fallbackMethod = "undertake"这个兜底方法也可以

package com.qiangqiang.service.impl;
    
    
    import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
    import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
    import com.qiangqiang.entity.Order;
    import com.qiangqiang.entity.Product;
    import com.qiangqiang.service.OrderService;
    import com.qiangqiang.service.ProductService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
    import org.springframework.core.ParameterizedTypeReference;
    import org.springframework.http.HttpMethod;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class OrderServiceImpl implements OrderService {
    
        @Autowired
        private ProductService productService;
    
        @HystrixCommand(
                groupKey = "order-server-list", // 一组command，如果没有配threadPoolKey，相同的groupKey会使用同一线程池（线程池隔离策略下）
                commandKey = "getOrder", // 服务标识，默认就是方法名
                threadPoolKey = "order-server-list", // 可以在多个方法上定义同一个线程池
                commandProperties = {
                        // 超时时间
                        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                                value = "5000")
                },
                threadPoolProperties = {
                        // 线程池大小
                        @HystrixProperty(name = "coreSize", value = "7"),
                        //队列等待阈值
                        @HystrixProperty(name = "maxQueueSize", value = "100"),
                        //线程存活时间
                        @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),
                        //超出队列等待阈值执行拒绝策略
                        @HystrixProperty(name = "queueSizeRejectionThreshold", value = "100")
                },fallbackMethod = "undertake1")        // 指定降级方法，在熔断和异常时会走降级方法
        @Override
        public Order getOrder(Integer id) {
            System.out.println(Thread.currentThread().getName()+"------------");
            Order order = new Order(1, "用户订单", 2, productService.getProductById(id));
            return order;
        }
    
    
        public Order undertake1(Integer id) {
            Order order = new Order(1, "用户订单兜底兜底", 2, productService.getProduct());
            return order;
        }
    
        @HystrixCommand(
                groupKey = "order-server-single", // 一组command，如果没有配threadPoolKey，相同的groupKey会使用同一线程池（线程池隔离策略下）
                commandKey = "getOrderById", // 服务标识，默认就是方法名
                threadPoolKey = "order-server-single", // 可以在多个方法上定义同一个线程池
                commandProperties = {
                        // 超时时间
                        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                                value = "5000")
                },
                threadPoolProperties = {
                        // 线程池大小
                        @HystrixProperty(name = "coreSize", value = "3"),
                        //队列等待阈值
                        @HystrixProperty(name = "maxQueueSize", value = "100"),
                        //线程存活时间
                        @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),
                        //超出队列等待阈值执行拒绝策略
                        @HystrixProperty(name = "queueSizeRejectionThreshold", value = "100")
                },fallbackMethod = "undertake")        // 指定降级方法，在熔断和异常时会走降级方法
        @Override
        public Order getOrderById() {
            System.out.println(Thread.currentThread().getName()+"------------");
            Order order = new Order(1, "用户订单", 2, productService.getProduct());
            return order;
        }
    
        public Order undertake() {
            Order order = new Order(1, "用户订单兜底兜底", 2, productService.getProduct());
            return order;
        }
    
    
    }

这样在一个接口方法压力大的时候，由于有线程池隔离，资源并没有耗尽，其他接口还是可以快速响应的