三、Hystrix信号量隔离技术的应用

/**

 * 资源隔离，两种策略:[线程池隔离][信号量隔离]

 * execution.isolation.strategy

 * 线程池机制:command运行在一个线程中，限流是通过线程池的大小来控制的,其实最大的好处就是对于网络访问请求，如果有超时的话，可以避免调用线程阻塞住

 * 信号量机制:command是运行在调用线程中，通过信号量的容量来进行限流,通常是针对超大并发量的场景下，每个服务实例每秒都几百的QPS，那么此时你用线程池的话，线程一般不会太多，可能撑不住那么高的并发，如果要撑住，可能要耗费大量的线程资源，那么就是用信号量，

 *          来进行限流保护线程池其实最大的好处就是对于网络访问请求，如果有超时的话，可以避免调用线程阻塞住

 *         

 * command线程池       

 * CommondKey:代表了一类command，一般来说代表了底层的依赖服务的一个接口

 * CommondGroup:默认情况下，因为就是通过command group来定义一个线程池的，统计信息，成功次数，[timeout(thread)]超时次数，失败次数，可以看到某一个服务整体的一些访问情况

 * CommondThreadpool:对于thread pool资源隔离来说，可能是希望能够拆分的更加一致一些，比如在一个功能模块内，对不同的请求可以使用不同的thread pool

 *

 * coreSize与queueSizeRejectionThreshold

 * coreSize:设置线程池的大小，默认是10

 * queueSizeRejectionThreshold:控制queue满后reject的threshold，因为maxQueueSize不允许热修改，因此提供这个参数可以热修改，控制队列的最大大小

 *

 * execution.isolation.semaphore.maxConcurrentRequests

 * 设置使用SEMAPHORE隔离策略的时候，允许访问的最大并发量，超过这个最大并发量，请求直接被reject,这个并发量的设置，跟线程池大小的设置，应该是类似的，但是基于信号量的话，性能会好很多，而且hystrix框架本身的开销会小很多

 * @author mawenbo

 *

 */

public class JointSchoolStatisticsContrastAnalysisSemaphoreCommand  extends  HystrixCommand<String>{

    public static Logger log = LoggerFactory.getLogger(JointSchoolStatisticsContrastAnalysisSemaphoreCommand.class);

    private String associatedId;

    private String schoolIds;

    private String courseId;

    private String url;

    public JointSchoolStatisticsContrastAnalysisSemaphoreCommand(String associatedId,String schoolIds,String courseId,String url) {

        super(Setter

                .withGroupKey(HystrixCommandGroupKey.Factory.asKey("AssociatedExamAllCourses"))

                .andCommandKey(HystrixCommandKey.Factory.asKey("jointSchoolStatisticsContrastAnalysis"))

//                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("AssociatedExamAllCoursesThreadPool"))

                .andCommandPropertiesDefaults(

                        HystrixCommandProperties.Setter()

                        .withExecutionIsolationStrategy(ExecutionIsolationStrategy.SEMAPHORE)

                        //设置使用SEMAPHORE隔离策略的时候，允许访问的最大并发量，超过这个最大并发量，请求直接被reject,默认是10

                        .withExecutionIsolationSemaphoreMaxConcurrentRequests(10)

                 )

//                .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter().withCoreSize(10).withQueueSizeRejectionThreshold(10))

                );

        this.associatedId = associatedId;

        this.schoolIds = schoolIds;

        this.courseId = courseId;

        this.url = url;

    }

    @Override

    protected String run() throws Exception {

          log.info(Thread.currentThread().getName()+"is running......"); 

          Map <String, String> param = Maps.newLinkedHashMap();

          param.put("associatedId", associatedId);

          param.put("schoolIds", schoolIds);

          param.put("courseId", courseId);

          try {

              String result = HttpClientUtils.simpleGetInvoke(url, param);

              log.info("联合考试 学校对比 获取成功：" + url + "?associatedId=" + associatedId + "&schoolIds=" + schoolIds + "&courseId=" + courseId);

              return result;

          } catch (Exception e) {

              log.error("联合考试 总分分析 获取成功：" + url + "?associatedId=" + associatedId + "&schoolIds=" + schoolIds + "&courseId=" + courseId, e);

              return null;

          }

    }

}