hystrix应用进阶

最新推荐文章于 2024-08-11 22:45:54 发布

liu1002880404

最新推荐文章于 2024-08-11 22:45:54 发布

阅读量209

点赞数 1

分类专栏： springCloud

本文链接：https://blog.csdn.net/liuerchong/article/details/106046184

版权

springCloud 专栏收录该内容

51 篇文章 1 订阅

订阅专栏

hystrix隔离分析

hystrix 有两种隔离方式，线程隔离，信号量的方式

(1)线程隔离

把执行依赖代码的线程与请求线程(如:jetty线程)分离，请求线程可以自由控制离开的时间(异步过程)。

通过线程池大小可以控制并发量，当线程池饱和时可以提前拒绝服务,防止依赖问题扩散。

线上建议线程池不要设置过大，否则大量堵塞线程有可能会拖慢服务器。

线程隔离的优缺点

线程隔离的优点:

[1]:使用线程可以完全隔离第三方代码,请求线程可以快速返回。
[2]:当一个失败的依赖再次变成可用时，线程池将清理，并立即恢复可用，而不是一个长时间的恢复。
[3]:可以完全模拟异步调用，方便异步编程。

线程隔离的缺点:

[1]:线程池的主要缺点是它增加了cpu，因为每个命令的执行涉及到排队(默认使用SynchronousQueue避免排队)，调度和上下文切换。
[2]:对使用ThreadLocal等依赖线程状态的代码增加复杂性，需要手动传递和清理线程状态。

- NOTE: Netflix公司内部认为线程隔离开销足够小，不会造成重大的成本或性能的影响。
- Netflix 内部API 每天100亿的HystrixCommand依赖请求使用线程隔，每个应用大约40多个线程池，每个线程池大约5-20个线程。

(2)信号隔离

- 信号隔离也可以用于限制并发访问，防止阻塞扩散, 与线程隔离最大不同在于执行依赖代码的线程依然是请求线程（该线程需要通过信号申请）,
- 如果客户端是可信的且可以快速返回，可以使用信号隔离替换线程隔离,降低开销.
- 信号量的大小可以动态调整, 线程池大小不可以.

线程隔离与信号隔离区别如下图:

上图可以看出，左边是线程池隔离,由主线程调用依赖后，依赖服务的执行是在新的HystrixCommand线程池中执行的，右边图中展示，信号量的方式，代码的执行还是在主线程中执行的。

实际hystrix应用场景介绍

现在大部分应用系统都是采用的分布式框架，系统中会有很多的依赖，HTTP、Dubbo、hession等等，在高并发场景下，这些依赖的服务稳定性对系统的影响很大，当依赖阻塞时,大多数服务器的线程池就出现阻塞(BLOCK),拖慢整条链路业务的执行，影响整个线上服务的稳定性，如果没有对依赖的服务做隔离就会出现这样的场景:

某次业务中通过监控发现某个接口RT猛增，通过pinpoint看到是依赖的一个接口响应时间比平时慢了很多，分析问题，该接口RT增加可能是因为依赖的下层接口响应时间变慢，大量请求都阻塞在接口调用处，还有个问题，该接口的dubbo超时时间设置的1秒，那这个接口影响1.2秒一点不奇怪，依赖接口都执行了1秒才会返回超时，问题分析到，接下来就是进行优化了。

优化过程

阶段一：尽可能少动，因为这个接口属于核心接口一旦出现问题可能影响较大，梳理出接口依赖的第三方服务，根据业务将所有依赖进行了划分，分出三个线程池，第一个核心线程池，该线程池用来处理业务所需的一些必须信息

第二个线程池，存放一些内部依赖的dubbo服务调用，第三个线程池，存放一些调用的http服务

为什么这么优化

不想改动太多逻辑，单纯的对接口做隔离，保证核心线程容量，非核心线程直接熔断或者干脆不调用，这也是对于突发大流量时，业务上的优化，非核心功能可以降级，只保证核心功能

还有个问题，既然核心线程的接口优先保证容量，那为什么还要单独交给新的线程池去处理，为什么不在主线程中执行呢？主线程在调用核心线程中的逻辑时一样是阻塞在那里，还会增加线程池之间的上下文切换时间，这里也不见得没有好处，我把核心代码隔离出来就可以精准的评估出我接口单台服务器能抗的最大并发数，这样在做容量保障时，就可以根据多少qps评估出要扩多少台机器。其实就是两者之间做一个取舍。

阶段二优化

通过阶段一的优化我们已经将该异步的接口做了异步，既然我们做了异步降级，那么也就是说非核心接口依赖的数据我们可以尝试提前将这部分数据查询出来拼接好放到某一个容器里边，我们需要的时候之间从该容器中获取，获取不到就直接返回null结果（类似阶段一接口熔断了）

二，hystrix代码的demo，供大家在使用的过程中快速上手

Hystrix有两个请求命令 HystrixCommand（该方式代码的执行由新创建的线程执行）、HystrixObservableCommand（该方式代码的执行还是在主线程中执行）。

　　HystrixCommand用在依赖服务返回单个操作结果的时候。有两种执行方式

　　 -execute():同步执行。从依赖的服务返回一个单一的结果对象，或是在发生错误的时候抛出异常。

　　 -queue();异步执行。直接返回一个Future对象，其中包含了服务执行结束时要返回的单一结果对象。

　　HystrixObservableCommand 用在依赖服务返回多个操作结果的时候。它也实现了两种执行方式

　　 -observe():返回Obervable对象，他代表了操作的多个结果，他是一个HotObservable

　　 -toObservable():同样返回Observable对象，也代表了操作多个结果，但它返回的是一个Cold Observable

HystrixCommand代码演示

import javafx.application.Application;
import org.hope.hystrix.example.HystrixApplication;
import org.hope.hystrix.example.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = HystrixApplication.class)
public class UserServiceTest {

@Autowired
private UserService userService;

/**
* 测试同步
*/
@Test
public void testGetUserId() {
System.out.println(Thread.currentThread().getName());
System.out.println("=================" + userService.getUserId("hystrix"));
}

/**
* 测试异步
*/
@Test
public void testGetUserName() throws ExecutionException, InterruptedException {
Future<String> fuature = userService.getUserName(30L,"hellow");
System.out.println("=================" + fuature.get());
}
}

/**
 * 用@HystrixCommand的方式来实现
 */
@Service
public class UserService {
    /**
     * 同步的方式。
     * fallbackMethod定义降级
     */
    @HystrixCommand(fallbackMethod = "helloFallback")
    public String getUserId(String name) {
        System.out.println(Thread.currentThread().getName());
        int i = 1/0; //此处抛异常，测试服务降级
        return "hellow:" + name;
    }

    public String helloFallback(String name) {
        return "error" + name;
    }

    //异步的执行
    @HystrixCommand(fallbackMethod = "getUserNameError")
    public Future<String> getUserName(final Long id, String name) {
        return new AsyncResult<String>() {
            @Override
            public String invoke() {
                    int i = 1/0;//此处抛异常,测试服务降级
                    return "你好:" + id;

            }
        };
    }

    public String getUserNameError(Long id, String name) {
        return "触发熔断啦！！！！";
    }
}

HystrixObservableCommand代码演示

package org.hope.hystrix.example.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.ObservableExecutionMode;
import org.springframework.stereotype.Service;
import rx.Observable;
import rx.Subscriber;

@Service
public class ObservableUserService {
/**
* EAGER参数表示使用observe()方式执行
*/
@HystrixCommand(observableExecutionMode = ObservableExecutionMode.EAGER, fallbackMethod = "observFailed") //使用observe()执行方式
public Observable<String> getUserById(final Long id) {
return Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
try {
if(!subscriber.isUnsubscribed()) {
subscriber.onNext("张三的ID:");
int i = 1 / 0; //抛异常，模拟服务降级
subscriber.onNext(String.valueOf(id));
subscriber.onCompleted();
}
} catch (Exception e) {
subscriber.onError(e);
}
}
});
}

private String observFailed(Long id) {
return "observFailed---->" + id;
}

/**
* LAZY参数表示使用toObservable()方式执行
*/
@HystrixCommand(observableExecutionMode = ObservableExecutionMode.LAZY, fallbackMethod = "toObserbableError") //表示使用toObservable()执行方式
public Observable<String> getUserByName(final String name) {
return Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
try {
if(!subscriber.isUnsubscribed()) {
subscriber.onNext("找到");
subscriber.onNext(name);
int i = 1/0; 抛异常，模拟服务降级
subscriber.onNext("了");
subscriber.onCompleted();
}
} catch (Exception e) {
subscriber.onError(e);
}
}
});
}

private String toObserbableError(String name) {
return "toObserbableError--->" + name;
}

}

package org.hope.hystrix.example.service;

import org.hope.hystrix.example.HystrixApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Iterator;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = HystrixApplication.class)
public class ObservableUserServiceTest {

    @Autowired
    private ObservableUserService observableUserService;

    @Test
    public void testObserve() {
        Iterator<String> iterator = observableUserService.getUserById(30L).toBlocking().getIterator();
        while(iterator.hasNext()) {
            System.out.println("===============" + iterator.next());
        }
    }

    @Test
    public void testToObservable() {
        Iterator<String> iterator = observableUserService.getUserByName("王五").toBlocking().getIterator();
        while(iterator.hasNext()) {
            System.out.println("===============" + iterator.next());
        }
    }
}

package org.hope.hystrix.example.service;

import org.hope.hystrix.example.HystrixApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Iterator;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = HystrixApplication.class)
public class ObservableUserServiceTest {

@Autowired
private ObservableUserService observableUserService;

@Test
public void testObserve() {
Iterator<String> iterator = observableUserService.getUserById(30L).toBlocking().getIterator();
while(iterator.hasNext()) {
System.out.println("===============" + iterator.next());
}
}

@Test
public void testToObservable() {
Iterator<String> iterator = observableUserService.getUserByName("王五").toBlocking().getIterator();
while(iterator.hasNext()) {
System.out.println("===============" + iterator.next());
}
}
}

项目中大多情况下都是用使用基于注解 HystrixCommand，上边说了HystrixCommand使用的是异步，代码逻辑的执行是在新的线程中执行的，可是释放掉当前的主线程，可以更大程度的提升代码的并发

针对如何进行hystrix参数配置做一些分析

复制代码

//异步的执行
    @HystrixCommand(groupKey = "testKey", commandKey = "testCommon", threadPoolKey = "getLiveVideoCoreThread", fallbackMethod = "getUserNameError",
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "500"),//指定多久超时，单位毫秒。超时进fallback
                    @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),//判断熔断的最少请求数，默认是10；只有在一个统计窗口内处理的请求数量达到这个阈值，才会进行熔断与否的判断
                    @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "10"),//判断熔断的阈值，默认值50，表示在一个统计窗口内有10%的请求处理失败，会触发熔断
                    @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "3000"),//熔断多少秒后去尝试请求
            },
            threadPoolProperties = {
                    @HystrixProperty(name = "coreSize", value = "20"),
                    @HystrixProperty(name = "maxQueueSize", value = "50"),
                    @HystrixProperty(name = "keepAliveTimeMinutes", value = "1"),
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "15"),
                    @HystrixProperty(name = "metrics.rollingStats.numBuckets", value = "10"),
                    @HystrixProperty(name = "metrics.rollingStats.timeInMilliseconds", value = "1000")})
    public Future<String> getUserName(final Long id, String name) {
        return new AsyncResult<String>() {
            @Override
            public String invoke() {
                    int i = 1/0;//此处抛异常,测试服务降级
                    return "你好:" + id;

            }
        };
    }

复制代码

fallbackMethod : 触发熔断器时执行的方法

GroupKey：该命令属于哪一个组，可以帮助我们更好的组织命令

CommandKey：该命令的名称

threadPoolKey：该命令所属线程池的名称，同样配置的命令会共享同一线程池，若不配置，会默认使用GroupKey作为线程池名称

commandProperties 配置解析

execution.isolation.thread.timeoutInMilliseconds ：指定多久超时，单位毫秒。超时进fallback

threadPoolProperties 配置解析

coreSize：配置核心线程池大小和线程池最大大小

maxQueueSize ：配置线程池队列最大大小