分析你的系统

你所认识的分布式系统，哪些是可以进行垂直拆分的？拆分之后系统之间的依赖如何梳理？系统异构之后的稳定性调用如何保证？这些都是可能在分布式场景中面临的问题。

说个比较常见的问题，大家都知道秒杀系统，秒杀流程在分布式的环境中，就需要依赖：订单管理，会员管理，支付等，假如在整个系统中会员系统不稳定，导致系统请求挤压，慢慢的就会导致对其他外部系统的依赖也不可用，所以就要使用业务的隔离，这样会避免服务的局部不可用导致的全部不可用。

Hystrix 源码分析

找到HystrixCommand的父类AbstractCommand， 里面有个构造方法，从构造方法可以看出里这里定义了 threadPool对象。代码如下，关键代码都有做相应的注释。

protected AbstractCommand(HystrixCommandGroupKey group, HystrixCommandKey key, HystrixThreadPoolKey threadPoolKey, HystrixCircuitBreaker circuitBreaker, HystrixThreadPool threadPool,

HystrixCommandProperties.Setter commandPropertiesDefaults, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults,

HystrixCommandMetrics metrics, TryableSemaphore fallbackSemaphore, TryableSemaphore executionSemaphore,

HystrixPropertiesStrategy propertiesStrategy, HystrixCommandExecutionHook executionHook) {

//commandGroup对象，用于组织一类业务相关的对象

this.commandGroup = initGroupKey(group);

// commandKey默认是以类为为名称的

this.commandKey = initCommandKey(key, getClass());

this.properties = initCommandProperties(this.commandKey, propertiesStrategy, commandPropertiesDefaults);

//这个方法里定义了TheradPool里的关键字，默认以传入的commandGroup 的name做为key的名称

this.threadPoolKey = initThreadPoolKey(threadPoolKey, this.commandGroup, this.properties.executionIsolationThreadPoolKeyOverride().get());

this.metrics = initMetrics(metrics, this.commandGroup, this.threadPoolKey, this.commandKey, this.properties);

this.circuitBreaker = initCircuitBreaker(this.properties.circuitBreakerEnabled().get(), circuitBreaker, this.commandGroup, this.commandKey, this.properties, this.metrics);

//这里就是线程池对象啦。

this.threadPool = initThreadPool(threadPool, this.threadPoolKey, threadPoolPropertiesDefaults);

//Strategies from plugins

this.eventNotifier = HystrixPlugins.getInstance().getEventNotifier();

this.concurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();

HystrixMetricsPublisherFactory.createOrRetrievePublisherForCommand(this.commandKey, this.commandGroup, this.metrics, this.circuitBreaker, this.properties);

this.executionHook = initExecutionHook(executionHook);

this.requestCache = HystrixRequestCache.getInstance(this.commandKey, this.concurrencyStrategy);

this.currentRequestLog = initRequestLog(this.properties.requestLogEnabled().get(), this.concurrencyStrategy);

/* fallback semaphore override if applicable */

this.fallbackSemaphoreOverride = fallbackSemaphore;

/* execution semaphore override if applicable */

this.executionSemaphoreOverride = executionSemaphore;

}

/**

这个方法用于得到HystrixThreadPoolKey 对象， Hystrix内部有大量的Key对象，可以简单理解这些 Key都是相应对象的唯一标识。从代码里可以看出，默认情况下Hystrix采用的是commandGroup 的name做为Thread Pool的key值。

**/

private static HystrixThreadPoolKey initThreadPoolKey(HystrixThreadPoolKey threadPoolKey, HystrixCommandGroupKey groupKey, String threadPoolKeyOverride) {

if (threadPoolKeyOverride == null) {

// we don't have a property overriding the value so use either HystrixThreadPoolKey or HystrixCommandGroup

if (threadPoolKey == null) {

/* use HystrixCommandGroup if HystrixThreadPoolKey is null */

return HystrixThreadPoolKey.Factory.asKey(groupKey.name());

} else {

return threadPoolKey;

}

} else {

// we have a property defining the thread-pool so use it instead

return HystrixThreadPoolKey.Factory.asKey(threadPoolKeyOverride);

}

}

/**

在这里将调用具体的构造线程池的方法。

**/

private static HystrixThreadPool initThreadPool(HystrixThreadPool fromConstructor, HystrixThreadPoolKey threadPoolKey, HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults) {

if (fromConstructor == null) {

// get the default implementation of HystrixThreadPool

return HystrixThreadPool.Factory.getInstance(threadPoolKey, threadPoolPropertiesDefaults);

} else {

return fromConstructor;

}

}