Hystrix从入门到放弃

于 2018-06-10 20:03:08 发布
阅读量1k 收藏 4
点赞数
分类专栏： Hystrix 文章标签： Hystrix 降级 熔断 合并 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ShiXueTanLang/article/details/80643890
版权

Hystrix框架简介

Hystrix翻译成中文是“豪猪”的意思。豪猪身上长满了刺，能保护自己不受天敌的伤害，代表了一种防御机制。因此Hystrix 的logo也是定义成了豪猪。


假设有如下场景：

比如我们现在有3个业务调用，分别是查询订单、查询商品、查询用户，且这三个业务请求都是依赖第三方服务—订单服务、商品服务、用户服务。三个服务均是通过RPC调用。当查询订单服务，假如线程阻塞了，这个时候后续有大量的查询订单请求过来，那么容器中的线程数量则会持续增加直至CPU资源耗尽，整个服务对外不可用，集群环境下就是雪崩。

Hystrix核心功能


线程隔离

  • 正常情况下，tomcat或其他容器的线程对外提供服务，接收用户请求。
  • Hystrix线程隔离的做法是：将tomcat线程处理的任务转交给Hystrix内部的线程去执行，这样tomcat线程就可以去做其他事情了。当Hystrix的线程将任务执行完后，将执行结果返回给tomcat线程。

信号量隔离

信号量的资源隔离只是起到一个开关的作用，例如，服务X的信号量大小为10，那么同时只允许10个tomcat的线程(此处是tomcat的线程，而不是服务X的独立线程池里面的线程)来访问服务X，其他的请求就会被拒绝，从而达到限流保护的作用。

线程隔离和信号量隔离对比



降级策略

  • 当请求出现了异常，超时，或者服务不可用的时候，一般情况你会怎么做？返回空，抛异常给调用方还是什么都不做？
  • Hystrix可以让你自定义降级策略。当发生异常的时候，返回你事先定义好的策略。比如空对象/默认值

熔断技术

  • 一般是指软件系统中，由于某些原因使得服务出现了过载现象，为防止造成整个系统故障，从而采用的一种保护措施，所以很多地方把熔断亦称为过载保护。很多时候刚开始可能只是系统出现了局部的、小规模的故障，然而由于种种原因，故障影响的范围越来越大，最终导致了全局性的后果。
  • 如果某个目标服务调用慢或者有大量超时，此时，熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。

请求缓存

  • 将请求缓存下来，当后续有相同的请求到来的时候，直接返回缓存中的响应，从而避免直接对服务进行调用，增加服务的压力
  • 比如根据用户id查询用户信息，根据商品id查询商品信息等，查询全国所有城市的邮编。这类实体的属性不会频繁的变动。

请求合并

将相同类型的请求合并成一次调用，而不是分别调用服务提供方，目的是降低服务提供方的压力。



Hystrix demo

HelloWorld demo：

public class CommandHelloWorld extends HystrixCommand<String> {

    private final String name;

    public CommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }

    @Override
    protected String run() {
        return "Hello " + name + "!";
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() {
            assertEquals("Hello World!", new CommandHelloWorld("World").execute());
            assertEquals("Hello Bob!", new CommandHelloWorld("Bob").execute());
        }

        @Test
        public void testAsynchronous1() throws Exception {
            assertEquals("Hello World!", new CommandHelloWorld("World").queue().get());
            assertEquals("Hello Bob!", new CommandHelloWorld("Bob").queue().get());
        }

        @Test
        public void testAsynchronous2() throws Exception {

            Future<String> fWorld = new CommandHelloWorld("World").queue();
            Future<String> fBob = new CommandHelloWorld("Bob").queue();

            assertEquals("Hello World!", fWorld.get());
            assertEquals("Hello Bob!", fBob.get());
        }

        @Test
        public void testObservable() throws Exception {

            Observable<String> fWorld = new CommandHelloWorld("World").observe();
            Observable<String> fBob = new CommandHelloWorld("Bob").observe();

            // blocking
            assertEquals("Hello World!", fWorld.toBlocking().single());
            assertEquals("Hello Bob!", fBob.toBlocking().single());

            // non-blocking
            // - this is a verbose anonymous inner-class approach and doesn't do assertions
            fWorld.subscribe(new Observer<String>() {

                @Override
                public void onCompleted() {
                    System.out.println("onCompleted here");
                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                }

                @Override
                public void onNext(String v) {
                    System.out.println("onNext: " + v);
                }

            });

            // non-blocking
            // - also verbose anonymous inner-class
            // - ignore errors and onCompleted signal
            fBob.subscribe(new Action1<String>() {

                @Override
                public void call(String v) {
                    System.out.println("onNext: " + v);
                }

            });

            // non-blocking
            // - using closures in Java 8 would look like this:

            //            fWorld.subscribe((v) -> {
            //                System.out.println("onNext: " + v);
            //            })

            // - or while also including error handling

            //            fWorld.subscribe((v) -> {
            //                System.out.println("onNext: " + v);
            //            }, (exception) -> {
            //                exception.printStackTrace();
            //            })

            // More information about Observable can be found at https://github.com/Netflix/RxJava/wiki/How-To-Use

        }
    }

}

上例中execute()方法是通过同步的方式执行任务；queue()方法是通过异步的防止执行任务。

new Observer<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted here");
    }

    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
    }

    @Override
    public void onNext(String v) {
        System.out.println("onNext: " + v);
    }
}

是对任务注册的回调事件。onCompleted是在任务执行完的时候回调，onError是在出现异常时候回调，onNext是获取结果后回调。三者的执行顺序是：onNext/onError完成之后最后回调onCompleted。

线程隔离和信号量隔离的demo:

package com.example.demo.hystrixdemo.isolation;

import com.netflix.hystrix.*;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 *
 * 测试线程池隔离策略
 * 设置线程池里的线程数＝3，然后循环>3次和<3次，最后查看当前所有线程名称
 * 
 */
public class HystrixCommand4ThreadPoolTest extends HystrixCommand<String> {

    private final String name;

    public HystrixCommand4ThreadPoolTest(String name) {
//        super(HystrixCommandGroupKey.Factory.asKey("ThreadPoolTestGroup"));
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ThreadPoolTestGroup"))  
                .andCommandKey(HystrixCommandKey.Factory.asKey("testCommandKey"))
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("ThreadPoolTest"))
                .andCommandPropertiesDefaults(
                	HystrixCommandProperties.Setter()
                		.withExecutionTimeoutInMilliseconds(5000)
                )
                .andThreadPoolPropertiesDefaults(
                	HystrixThreadPoolProperties.Setter()
                		.withCoreSize(3)	// 配置线程池里的线程数
                )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
    	/*---------------会触发fallback的case-------------------*/
//    	int j = 0;
//    	while (true) {
//    		j++;
    		return "a";
//    	}
    	// 除零异常
//    	int i = 1/0;
    	
    	// 主动抛出异常
//        throw new HystrixTimeoutException();
//        throw new RuntimeException("this command will trigger fallback");
//        throw new Exception("this command will trigger fallback");
//    	throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, commandClass, message, cause, fallbackException);
        
    	/*---------------不会触发fallback的case-------------------*/
    	// 被捕获的异常不会触发fallback
//    	try {
//    		throw new RuntimeException("this command never trigger fallback");
//    	} catch(Exception e) {
//    		e.printStackTrace();
//    	}
        
    	// HystrixBadRequestException异常由非法参数或非系统错误引起，不会触发fallback，也不会被计入熔断器
//        throw new HystrixBadRequestException("HystrixBadRequestException is never trigger fallback");
    	TimeUnit.MILLISECONDS.sleep(2000);
		System.out.println(Thread.currentThread().getName() + ": " + name);
		return name;
    }

    @Override
    protected String getFallback() {
        return "fallback: " + name;
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException {
        	for(int i = 0; i < 3; i++) {
	        	try {
//	        		assertEquals("fallback: Hlx", new HystrixCommand4ThreadPoolTest("Hlx").execute());
//	        		System.out.println("===========" + new HystrixCommand4ThreadPoolTest("Hlx").execute());
					//占有线程池中的线程
	        		Future<String> future = new HystrixCommand4ThreadPoolTest("get available thread" + i).queue();
	        		//强制阻塞
//					System.out.println("future返回：" + future.get());
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}
        	for(int i = 0; i < 10; i++) {
	        	try {
	//        		assertEquals("fallback: Hlx", new HystrixCommand4ThreadPoolTest("Hlx").execute());
	        		System.out.println("===========" + new HystrixCommand4ThreadPoolTest(" not get available thread" + i).execute());
//	        		Future<String> future = new HystrixCommand4ThreadPoolTest("Hlx1"+i).queue();
//	        		System.out.println("===========" + future);
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}
        	try {
        		TimeUnit.MILLISECONDS.sleep(2000);
        	}catch(Exception e) {}
        	System.out.println("------开始打印现有线程---------");
        	Map<Thread, StackTraceElement[]> map=Thread.getAllStackTraces();
        	for (Thread thread : map.keySet()) {
				System.out.println(thread.getName());
			}
        	System.out.println(map);
        	System.out.println("thread num: " + map.size());
//        	int numExecuted = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size();
//            System.out.println("num executed: " + numExecuted);
        }
    }

}
package com.example.demo.hystrixdemo.isolation;

import com.example.demo.hystrixdemo.HelloWorldHystrixCommand;
import com.netflix.hystrix.*;
import com.netflix.hystrix.HystrixCommandProperties.ExecutionIsolationStrategy;
import org.junit.Test;

import java.io.IOException;

/**
 * 测试信号量隔离策略
 * 默认执行run()用的是主线程，为了模拟并行执行command，这里我们自己创建多个线程来执行command
 * 设置ExecutionIsolationSemaphoreMaxConcurrentRequests为3，意味着信号量最多允许执行run的并发数为3，超过则触发降级，即不执行run而执行getFallback
 * 设置FallbackIsolationSemaphoreMaxConcurrentRequests为1，意味着信号量最多允许执行fallback的并发数为1，超过则抛异常fallback execution rejected
 */
public class HystrixCommand4SemaphoreTest extends HystrixCommand<String> {

    private final String name;

    public HystrixCommand4SemaphoreTest(String name) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("SemaphoreTestGroup"))
                        .andCommandKey(HystrixCommandKey.Factory.asKey("SemaphoreTestKey"))
                        .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("SemaphoreTestThreadPoolKey"))
                        .andCommandPropertiesDefaults(    // 配置信号量隔离
                                HystrixCommandProperties.Setter()
                                        .withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)    // 信号量隔离
                                        .withExecutionIsolationSemaphoreMaxConcurrentRequests(3)
                                        .withFallbackIsolationSemaphoreMaxConcurrentRequests(1)
                        )
                // 设置了信号量隔离后，线程池配置将变无效
//                .andThreadPoolPropertiesDefaults(
//                		HystrixThreadPoolProperties.Setter()
//                		.withCoreSize(13)	// 配置线程池里的线程数
//                )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
        return "run(): name=" + name + "，线程名是" + Thread.currentThread().getName();
    }

    @Override
    protected String getFallback() {
        return "getFallback(): name=" + name + "，线程名是" + Thread.currentThread().getName();
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException, InterruptedException {

            try {
                Thread.sleep(2000);
                for (int i = 0; i < 5; i++) {
                    final int j = i;
                    // 自主创建线程来执行command，创造并发场景
                    //	                    @Override
                    Thread thread = new Thread(() -> {
                        // 这里执行两类command：HystrixCommand4SemaphoreTest设置了信号量隔离、HelloWorldHystrixCommand未设置信号量
                        System.out.println("-----------" + new HelloWorldHystrixCommand("HelloWorldHystrixCommand" + j).execute());
                        System.out.println("===========" + new HystrixCommand4SemaphoreTest("HystrixCommand4SemaphoreTest" + j).execute());    // 被信号量拒绝的线程从这里抛出异常
                        System.out.println("-----------" + new HelloWorldHystrixCommand("HelloWorldHystrixCommand" + j).execute());    // 被信号量拒绝的线程不能执行到这里

                    });
                    thread.start();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
//        	try {
//        		TimeUnit.MILLISECONDS.sleep(2000);
//        	}catch(Exception e) {}
//            System.out.println("------开始打印现有线程---------");
//            Map<Thread, StackTraceElement[]> map = Thread.getAllStackTraces();
//            for (Thread thread : map.keySet()) {
//                System.out.println(thread.getName());
//            }
//            System.out.println("thread num: " + map.size());
//        	System.in.read();
            Thread.sleep(4000);
        }
    }

}

降级策略demo:

/**
 *
 * 以下四种情况将触发getFallback调用：
 * 1）run()方法抛出非HystrixBadRequestException异常
 * 2）run()方法调用超时
 * 3）熔断器开启拦截调用
 * 4）线程池/队列/信号量是否跑满
 *
 * 实现getFallback()后，执行命令时遇到以上4种情况将被fallback接管，不会抛出异常或其他
 */
public class HystrixFallback4ExceptionTest extends HystrixCommand<String> {

    private final String name;

    public HystrixFallback4ExceptionTest(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("FallbackGroup"));
        this.name = name;
    }

    @Override
    protected String run() throws Exception {

    	/*---------------会触发fallback的case-------------------*/
        // 无限循环，实际上属于超时
//    	int j = 0;
//    	while (true) {
//    		j++;
//    	}


        // 除零异常
//    	int i = 1/0;


        // 主动抛出异常
//        throw new HystrixTimeoutException();
//        throw new RuntimeException("this command will trigger fallback");
//        throw new Exception("this command will trigger fallback");
//    	throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, commandClass, message, cause, fallbackException);

    	/*---------------不会触发fallback的case-------------------*/
        // 被捕获的异常不会触发fallback
//    	try {
//    		throw new RuntimeException("this command never trigger fallback");
//    	} catch(Exception e) {
//    		e.printStackTrace();
//    	}

        // HystrixBadRequestException异常由非法参数或非系统错误引起，不会触发fallback，也不会被计入熔断器
        throw new HystrixBadRequestException("HystrixBadRequestException is never trigger fallback");

//		return name;
    }

    @Override
    protected String getFallback() {
        return "fallback: " + name;
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException {
            try {
                System.out.println(new HystrixFallback4ExceptionTest("ExceptionTest").execute());
            } catch(Exception e) {
                System.out.println("run()抛出HystrixBadRequestException时，会被捕获到这里" + e.getCause());
            }
//        	System.in.read();
        }
    }

}

package com.example.demo.hystrixdemo.fallback;

import com.netflix.hystrix.*;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 
 * 设置线程池里的线程数＝3，然后循环>3次和<3次，最后查看当前所有线程名称
 * 
 */
public class HystrixCommand4ThreadPoolTest extends HystrixCommand<String> {

    private final String name;

    public HystrixCommand4ThreadPoolTest(String name) {
//        super(HystrixCommandGroupKey.Factory.asKey("ThreadPoolTestGroup"));
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ThreadPoolTestGroup"))  
                .andCommandKey(HystrixCommandKey.Factory.asKey("testCommandKey"))
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("ThreadPoolTest"))
                .andCommandPropertiesDefaults(
                	HystrixCommandProperties.Setter()
                		.withExecutionTimeoutInMilliseconds(5000)
                )
                .andThreadPoolPropertiesDefaults(
                	HystrixThreadPoolProperties.Setter()
                		.withCoreSize(3)	// 配置线程池里的线程数
                )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
    	/*---------------会触发fallback的case-------------------*/
//    	int j = 0;
//    	while (true) {
//    		j++;
    		return "a";
//    	}
    	// 除零异常
//    	int i = 1/0;
    	
    	// 主动抛出异常
//        throw new HystrixTimeoutException();
//        throw new RuntimeException("this command will trigger fallback");
//        throw new Exception("this command will trigger fallback");
//    	throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, commandClass, message, cause, fallbackException);
        
    	/*---------------不会触发fallback的case-------------------*/
    	// 被捕获的异常不会触发fallback
//    	try {
//    		throw new RuntimeException("this command never trigger fallback");
//    	} catch(Exception e) {
//    		e.printStackTrace();
//    	}
        
    	// HystrixBadRequestException异常由非法参数或非系统错误引起，不会触发fallback，也不会被计入熔断器
//        throw new HystrixBadRequestException("HystrixBadRequestException is never trigger fallback");
    	TimeUnit.MILLISECONDS.sleep(2000);
		System.out.println(Thread.currentThread().getName() + ": " + name);
		return name;
    }

    @Override
    protected String getFallback() {
        return "fallback: " + name;
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException {
        	for(int i = 0; i < 3; i++) {
	        	try {
//	        		assertEquals("fallback: Hlx", new HystrixCommand4ThreadPoolTest("Hlx").execute());
//	        		System.out.println("===========" + new HystrixCommand4ThreadPoolTest("Hlx").execute());
					//占有线程池中的线程
	        		Future<String> future = new HystrixCommand4ThreadPoolTest("get available thread" + i).queue();
	        		//强制阻塞
//					System.out.println("future返回：" + future.get());
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}
        	for(int i = 0; i < 10; i++) {
	        	try {
	//        		assertEquals("fallback: Hlx", new HystrixCommand4ThreadPoolTest("Hlx").execute());
	        		System.out.println("===========" + new HystrixCommand4ThreadPoolTest(" not get available thread" + i).execute());
//	        		Future<String> future = new HystrixCommand4ThreadPoolTest("not get available thread" + i).queue();
//	        		System.out.println("===========" + future.get());
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}
        	try {
        		TimeUnit.MILLISECONDS.sleep(2000);
        	}catch(Exception e) {}
        	System.out.println("------开始打印现有线程---------");
        	Map<Thread, StackTraceElement[]> map=Thread.getAllStackTraces();
        	for (Thread thread : map.keySet()) {
				System.out.println(thread.getName());
			}
        	System.out.println(map);
        	System.out.println("thread num: " + map.size());
//        	int numExecuted = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size();
//            System.out.println("num executed: " + numExecuted);
        }
    }

}
package com.example.demo.hystrixdemo.fallback;

import com.netflix.hystrix.*;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

/**
 * 
 * CircuitBreakerRequestVolumeThreshold设置为3，意味着10s内请求超过3次就触发熔断器
 * run()中无限循环使命令超时进入fallback，执行3次run后，将被熔断，进入降级，即不进入run()而直接进入fallback
 * 如果未熔断，但是threadpool被打满，仍然会降级，即不进入run()而直接进入fallback
 */
public class HystrixCommand4CircuitBreakerTest extends HystrixCommand<String> {

    private final String name;

    public HystrixCommand4CircuitBreakerTest(String name) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("CircuitBreakerTestGroup"))  
                .andCommandKey(HystrixCommandKey.Factory.asKey("CircuitBreakerTestKey"))
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("CircuitBreakerTest"))
                .andThreadPoolPropertiesDefaults(	// 配置线程池
                		HystrixThreadPoolProperties.Setter()
                		.withCoreSize(200)	// 配置线程池里的线程数，设置足够多线程，以防未熔断却打满threadpool
                )
                .andCommandPropertiesDefaults(	// 配置熔断器
                		HystrixCommandProperties.Setter()
                		.withCircuitBreakerEnabled(true)
                		.withCircuitBreakerRequestVolumeThreshold(3)
                		.withCircuitBreakerErrorThresholdPercentage(80)
//                		.withCircuitBreakerForceOpen(true)	// 置为true时，所有请求都将被拒绝，直接到fallback
//                		.withCircuitBreakerForceClosed(true)	// 置为true时，将忽略错误
//                		.withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)	// 信号量隔离
//                		.withExecutionTimeoutInMilliseconds(5000)
                )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
    	System.out.println("running run():" + name);
    	int num = Integer.valueOf(name);
    	if(num % 2 == 0 && num < 10) {	// 直接返回
    		return name;
    	} else {	// 无限循环模拟超时
    		int j = 0;
        	while (true) {
        		j++;
        	}
    	}
//		return name;
    }

    @Override
    protected String getFallback() {
        return "CircuitBreaker fallback: " + name;
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException {
        	for(int i = 0; i < 50; i++) {
	        	try {
	        		System.out.println("===========" + new HystrixCommand4CircuitBreakerTest(String.valueOf(i)).execute());
//	        		try {
//	            		TimeUnit.MILLISECONDS.sleep(1000);
//	            	}catch(Exception e) {}
//	        		Future<String> future = new HystrixCommand4CircuitBreakerTest("Hlx"+i).queue();
//	        		System.out.println("===========" + future);
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}

        	System.out.println("------开始打印现有线程---------");
        	Map<Thread, StackTraceElement[]> map=Thread.getAllStackTraces();
        	for (Thread thread : map.keySet()) {
				System.out.println(thread.getName());
			}
        	System.out.println("thread num: " + map.size());
        	
        	System.in.read();
        }
    }

}

Hystrix执行流程图：

请求合并的demo：

package com.example.demo.hystrixdemo.collapsing;

import com.netflix.hystrix.HystrixCollapser;
import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandKey;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * Sample {@link HystrixCollapser} that automatically batches multiple requests to execute()/queue()
 * into a single {@link HystrixCommand} execution for all requests within the defined batch (time or size).
 */
public class HelloWorldHystrixCollapser extends HystrixCollapser<List<String>, String, Integer> {

    private final Integer key;

    public HelloWorldHystrixCollapser(Integer key) {
        this.key = key;
    }

    @Override
    public Integer getRequestArgument() {
        return key;
    }

    // 创建一个批量请求命令
    @Override
    protected HystrixCommand<List<String>> createCommand(final Collection<CollapsedRequest<String, Integer>> requests) {
        return new BatchCommand(requests); // 把批量请求传给command类
    }

    // 把批量请求的结果和对应的请求一一对应起来
    @Override
    protected void mapResponseToRequests(List<String> batchResponse, Collection<CollapsedRequest<String, Integer>> requests) {
        int count = 0;
        for (CollapsedRequest<String, Integer> request : requests) {
            request.setResponse(batchResponse.get(count++));
        }
    }

    // command类
    private static final class BatchCommand extends HystrixCommand<List<String>> {
        private final Collection<CollapsedRequest<String, Integer>> requests;

        private BatchCommand(Collection<CollapsedRequest<String, Integer>> requests) {
            super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("CollepsingGroup"))
                    .andCommandKey(HystrixCommandKey.Factory.asKey("CollepsingKey")));
            this.requests = requests;
        }

        @Override
        protected List<String> run() {
            ArrayList<String> response = new ArrayList<String>();
            // 处理每个请求，返回结果
            for (CollapsedRequest<String, Integer> request : requests) {
                // artificial response for each argument received in the batch
                response.add("ValueForKey: " + request.getArgument() + " thread:" + Thread.currentThread().getName());
            }
            return response;
        }
    }
}
package com.example.demo.hystrixdemo.collapsing;

import com.netflix.hystrix.HystrixEventType;
import com.netflix.hystrix.HystrixInvokableInfo;
import com.netflix.hystrix.HystrixRequestLog;
import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
import org.junit.Test;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

/**
 * 相邻两个请求可以自动合并的前提是两者足够“近”：启动执行的间隔时间足够小，默认10ms
 * 
 */
public class HystrixCommand4RequestCollapsingTest {
        @Test
        public void testCollapser() throws Exception {
            HystrixRequestContext context = HystrixRequestContext.initializeContext();
            try {
               
                Future<String> f1 = new HelloWorldHystrixCollapser(1).queue();
                Future<String> f2 = new HelloWorldHystrixCollapser(2).queue();
//                System.out.println(new HelloWorldHystrixCollapser(1).execute()); // 这条很可能会合并到f1和f2的批量请求中
//                System.out.println(new HelloWorldHystrixCollapser(1).execute()); // 由于上面有IO打印，这条很可能不会合并到f1和f2的批量请求中
                Future<String> f3 = new HelloWorldHystrixCollapser(3).queue();
                Future<String> f4 = new HelloWorldHystrixCollapser(4).queue();

                Future<String> f5 = new HelloWorldHystrixCollapser(5).queue();
                // f5和f6，如果sleep时间够小则会合并，如果sleep时间够大则不会合并，默认10ms
//                TimeUnit.MILLISECONDS.sleep(10);
                Future<String> f6 = new HelloWorldHystrixCollapser(6).queue();              
          
                System.out.println(System.currentTimeMillis() + " : " + f1.get());
                System.out.println(System.currentTimeMillis() + " : " + f2.get());
                System.out.println(System.currentTimeMillis() + " : " + f3.get());
                System.out.println(System.currentTimeMillis() + " : " + f4.get());
                System.out.println(System.currentTimeMillis() + " : " + f5.get());
                System.out.println(System.currentTimeMillis() + " : " + f6.get());
                // 下面3条都不在一个批量请求中
//                System.out.println(new HelloWorldHystrixCollapser(7).execute());
//                System.out.println(new HelloWorldHystrixCollapser(8).queue().get());
//                System.out.println(new HelloWorldHystrixCollapser(9).queue().get());

                // note：numExecuted表示共有几个命令执行，1个批量多命令请求算一个，这个实际值可能比代码写的要多，因为due to non-determinism of scheduler since this example uses the real timer
                int numExecuted = HystrixRequestLog.getCurrentRequest().getAllExecutedCommands().size();
                System.out.println(System.currentTimeMillis() + " : " + "num executed: " + numExecuted);
                int numLogs = 0;
                for (HystrixInvokableInfo<?> command : HystrixRequestLog.getCurrentRequest().getAllExecutedCommands()) {
                    numLogs++;
                    
                    // assert the command is the one we're expecting
//                    assertEquals("CollepsingKey", command.getCommandKey().name());

                    System.out.println(System.currentTimeMillis() + " : " + command.getCommandKey().name() + " => command.getExecutionEvents(): " + command.getExecutionEvents());

                    // confirm that it was a COLLAPSED command execution
//                    assertTrue(command.getExecutionEvents().contains(HystrixEventType.COLLAPSED));
                    assertTrue(command.getExecutionEvents().contains(HystrixEventType.SUCCESS));
                }
                assertEquals(numExecuted, numLogs);
            } finally {
                context.shutdown();
            }
        }
}

hystrix支持N个请求自动合并为一个请求，这个功能在有网络交互的场景下尤其有用，比如每个请求都要网络访问远程资源，如果把请求合并为一个，将使多次网络交互变成一次，极大节省开销。重要一点，两个请求能自动合并的前提是两者足够“近”，即两者启动执行的间隔时长要足够小，默认为10ms，即超过10ms将不自动合并。

以demo为例，我们连续发起多个queue请求，依次返回f1~f6共6个Future对象，根据打印结果可知f1~f5同处一个线程，说明这5个请求被合并了，而f6由另一个线程执行，这是因为f5和f6中间隔了一个sleep，超过了合并要求的最大间隔时长。

请求熔断的demo：

package com.example.demo.hystrixdemo.circuitbreak;

import com.netflix.hystrix.*;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

/**
 * 
 * CircuitBreakerRequestVolumeThreshold设置为3，意味着10s内请求超过3次就触发熔断器
 * run()中无限循环使命令超时进入fallback，执行3次run后，将被熔断，进入降级，即不进入run()而直接进入fallback
 * 如果未熔断，但是threadpool被打满，仍然会降级，即不进入run()而直接进入fallback
 */
public class HystrixCommand4CircuitBreakerTest extends HystrixCommand<String> {

    private final String name;

    public HystrixCommand4CircuitBreakerTest(String name) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("CircuitBreakerTestGroup"))  
                .andCommandKey(HystrixCommandKey.Factory.asKey("CircuitBreakerTestKey"))
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("CircuitBreakerTest"))
                .andThreadPoolPropertiesDefaults(	// 配置线程池
                		HystrixThreadPoolProperties.Setter()
                		.withCoreSize(200)	// 配置线程池里的线程数，设置足够多线程，以防未熔断却打满threadpool
                )
                .andCommandPropertiesDefaults(	// 配置熔断器
                		HystrixCommandProperties.Setter()
                		.withCircuitBreakerEnabled(true)
                		.withCircuitBreakerRequestVolumeThreshold(3)
                		.withCircuitBreakerErrorThresholdPercentage(80)
//                		.withCircuitBreakerForceOpen(true)	// 置为true时，所有请求都将被拒绝，直接到fallback
//                		.withCircuitBreakerForceClosed(true)	// 置为true时，将忽略错误
//                		.withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)	// 信号量隔离
//                		.withExecutionTimeoutInMilliseconds(5000)
                )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
    	System.out.println("running run():" + name);
    	int num = Integer.valueOf(name);
    	if(num % 2 == 0 && num < 10) {	// 直接返回
    		return name;
    	} else {	// 无限循环模拟超时
    		int j = 0;
        	while (true) {
        		j++;
        	}
    	}
//		return name;
    }

    @Override
    protected String getFallback() {
        return "CircuitBreaker fallback: " + name;
    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException {
        	for(int i = 0; i < 50; i++) {
	        	try {
	        		System.out.println("===========" + new HystrixCommand4CircuitBreakerTest(String.valueOf(i)).execute());
//	        		try {
//	            		TimeUnit.MILLISECONDS.sleep(1000);
//	            	}catch(Exception e) {}
//	        		Future<String> future = new HystrixCommand4CircuitBreakerTest("Hlx"+i).queue();
//	        		System.out.println("===========" + future);
	        	} catch(Exception e) {
	        		System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
	        	}
        	}

        	System.out.println("------开始打印现有线程---------");
        	Map<Thread, StackTraceElement[]> map=Thread.getAllStackTraces();
        	for (Thread thread : map.keySet()) {
				System.out.println(thread.getName());
			}
        	System.out.println("thread num: " + map.size());
        	
        }
    }

}
熔断机制相当于电路的跳闸功能，举个栗子，我们可以配置熔断策略为当请求错误比例在10s内>50%时，该服务将进入熔断状态，后续请求都会进入fallback。

以demo为例，我们通过withCircuitBreakerRequestVolumeThreshold配置10s内请求数超过3个时熔断器开始生效，通过withCircuitBreakerErrorThresholdPercentage配置错误比例>80%时开始熔断，然后for循环执行execute()触发run()，在run()里，如果name是小于10的偶数则正常返回，否则超时，通过多次循环后，超时请求占所有请求的比例将大于80%，就会看到后续请求都不进入run()而是进入getFallback()，因为不再打印"running run():" + name了。

请求缓存的demo：

package com.example.demo.hystrixdemo.cache;

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

/**
 * cache只有同在一个context中才生效
 * 通过HystrixRequestContext.initializeContext()初始化context，通过shutdown()关闭context
 */
public class HystrixCommand4RequestCacheTest extends HystrixCommand<Boolean> {

    private final int value;
    private final String value1;

    protected HystrixCommand4RequestCacheTest(int value, String value1) {
        super(HystrixCommandGroupKey.Factory.asKey("RequestCacheCommandGroup"));
        this.value = value;
        this.value1 = value1;
    }

    // 返回结果是cache的value
    @Override
    protected Boolean run() {
        return value == 0 || value % 2 == 0;
    }

    // 构建cache的key
    @Override
    protected String getCacheKey() {
        return String.valueOf(value) + value1;
    }

    public static class UnitTest {

        @Test
        public void testWithoutCacheHits() {
            HystrixRequestContext context = HystrixRequestContext.initializeContext();
            try {
                assertTrue(new HystrixCommand4RequestCacheTest(2,"HLX").execute());
                assertFalse(new HystrixCommand4RequestCacheTest(1,"HLX").execute());
                assertTrue(new HystrixCommand4RequestCacheTest(0,"HLX").execute());
                assertTrue(new HystrixCommand4RequestCacheTest(58672,"HLX").execute());
            } finally {
                context.shutdown();
            }
        }

        @Test
        public void testWithCacheHits() {
            HystrixRequestContext context = HystrixRequestContext.initializeContext();
            try {
                HystrixCommand4RequestCacheTest command2a = new HystrixCommand4RequestCacheTest(2,"HLX");
                HystrixCommand4RequestCacheTest command2b = new HystrixCommand4RequestCacheTest(2,"HLX");
                HystrixCommand4RequestCacheTest command2c = new HystrixCommand4RequestCacheTest(2,"HLX1");

                assertTrue(command2a.execute());
                // this is the first time we've executed this command with the value of "2" so it should not be from cache
                assertFalse(command2a.isResponseFromCache());

                assertTrue(command2b.execute());
                // this is the second time we've executed this command with the same value so it should return from cache
                assertTrue(command2b.isResponseFromCache());
                
                assertTrue(command2c.execute());
                assertFalse(command2c.isResponseFromCache());
            } finally {
                context.shutdown();
            }

            // start a new request context
            context = HystrixRequestContext.initializeContext();
            try {
                HystrixCommand4RequestCacheTest command3a = new HystrixCommand4RequestCacheTest(2,"HLX");
                HystrixCommand4RequestCacheTest command3b = new HystrixCommand4RequestCacheTest(2,"HLX");
                assertTrue(command3a.execute());
                // this is a new request context so this should not come from cache
                assertFalse(command3a.isResponseFromCache());
                // 从command3a.execute()执行中得到的cache
                command3b.execute();
                assertTrue(command3b.isResponseFromCache());
            } finally {
                context.shutdown();
            }
        }
    }

}
hystrix支持将一个请求结果缓存起来，下一个具有相同key的请求将直接从缓存中取出结果，减少请求开销。要使用hystrix cache功能，第一个要求是重写getCacheKey()，用来构造cache key；第二个要求是构建context，如果请求B要用到请求A的结果缓存，A和B必须同处一个context。通过HystrixRequestContext.initializeContext()和context.shutdown()可以构建一个context，这两条语句间的所有请求都处于同一个context。
以demo的testWithCacheHits()为例，command2a、command2b、command2c同处一个context，前两者的cache key都是2HLX（见getCacheKey()），所以command2a执行完后把结果缓存，
command2b执行时就不走run()而是直接从缓存中取结果了，而command2c的cache key是2HLX1，无法从缓存中取结果。此外，通过isResponseFromCache()可检查返回结果是否来自缓存。

源码地址：

https://github.com/PerseveranceForever/hystrix_demo.git 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值