Java HystrixConcurrencyStrategy类代码示例

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
/**
 * registers the {@link ExecutionContextAwareHystrixStrategy}
 */
public static void init() {
    // keeps references of existing Hystrix plugins.
    HystrixConcurrencyStrategy existingConcurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
    HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
    HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();
    HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance().getPropertiesStrategy();
    HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance().getCommandExecutionHook();
    // reset the Hystrix plugin
    HystrixPlugins.reset();
    // configure the  plugin
    HystrixPlugins.getInstance().registerConcurrencyStrategy(new ExecutionContextAwareHystrixStrategy(existingConcurrencyStrategy));
    HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
    HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
    HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
    HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
    log.info("Context propagation enabled for Hystrix.");
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Override
public void bindTo(MeterRegistry registry) {
    // Keeps references of existing Hystrix plugins.
    HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
    HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance().getPropertiesStrategy();
    HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance().getCommandExecutionHook();
    HystrixConcurrencyStrategy concurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();

    HystrixPlugins.reset();

    // Registers existing plugins except the new MicroMeter Strategy plugin.
    HystrixPlugins.getInstance().registerMetricsPublisher(new MicrometerMetricsPublisher(registry));
    HystrixPlugins.getInstance().registerConcurrencyStrategy(concurrencyStrategy);
    HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
    HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
    HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Before
public void setUp() {
    final HystrixPlugins plugins = HystrixPlugins.getInstance();
    final HystrixConcurrencyStrategy delegate = new HystrixConcurrencyStrategy() {
        @Override
        public <T> Callable<T> wrapCallable(final Callable<T> callable) {
            return () -> {
                // to verify that the delegate has already access to the trace
                assertThat(trace.getValue(), is("76f6046c-1b56-11e6-8c85-8fc9ee29f631"));
                return callable.call();
            };
        }
    };
    plugins.registerConcurrencyStrategy(new TracerConcurrencyStrategy(tracer, delegate));
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Test
public void should_delegate_work_to_custom_hystrix_concurrency_strategy()
		throws Exception {
	HystrixConcurrencyStrategy strategy = Mockito.mock(HystrixConcurrencyStrategy.class);
	HystrixPlugins.getInstance().registerConcurrencyStrategy(strategy);
	SleuthHystrixConcurrencyStrategy sleuthStrategy = new SleuthHystrixConcurrencyStrategy(
			this.tracer, this.traceKeys);

	sleuthStrategy.wrapCallable(() -> "foo");
	sleuthStrategy.getThreadPool(HystrixThreadPoolKey.Factory.asKey(""), Mockito.mock(
			HystrixThreadPoolProperties.class));
	sleuthStrategy.getThreadPool(HystrixThreadPoolKey.Factory.asKey(""),
			Mockito.mock(HystrixProperty.class), Mockito.mock(HystrixProperty.class),
			Mockito.mock(HystrixProperty.class), TimeUnit.DAYS, Mockito.mock(
					BlockingQueue.class));
	sleuthStrategy.getBlockingQueue(10);
	sleuthStrategy.getRequestVariable(Mockito.mock(
			HystrixLifecycleForwardingRequestVariable.class));

	BDDMockito.then(strategy).should().wrapCallable((Callable) BDDMockito.any());
	BDDMockito.then(strategy).should().getThreadPool(BDDMockito.any(), BDDMockito.any());
	BDDMockito.then(strategy).should().getThreadPool(BDDMockito.any(), BDDMockito.any(),
			BDDMockito.any(), BDDMockito.any(), BDDMockito.any(), BDDMockito.any());
	BDDMockito.then(strategy).should().getThreadPool(BDDMockito.any(), BDDMockito.any(),
			BDDMockito.any(), BDDMockito.any(), BDDMockito.any(), BDDMockito.any());
	BDDMockito.then(strategy).should().getBlockingQueue(10);
	BDDMockito.then(strategy).should().getRequestVariable(BDDMockito.any());
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public HystrixStrategies(HystrixPropertiesStrategy hystrixPropertiesStrategy,
						 HystrixConcurrencyStrategy concurrencyStrategy,
						 HystrixEventNotifier eventNotifier,
						 String id) {
	this.hystrixPropertiesStrategy = hystrixPropertiesStrategy;
	this.hystrixConcurrencyStrategy = concurrencyStrategy;
	this.hystrixEventNotifier = eventNotifier;
	this.id = id;
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Test
public void getJsr236ConcurrencyStrategy() throws Exception {
    HystrixConcurrencyStrategy concurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
    assertThat(concurrencyStrategy, is(notNullValue()));
    assertThat(concurrencyStrategy, instanceOf(HystrixConcurrencyStrategyJsr236.class));
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public TracerConcurrencyStrategy(final Tracer tracer, final HystrixConcurrencyStrategy delegate) {
    this.tracer = tracer;
    this.delegate = delegate;
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Override
protected HystrixConcurrencyStrategy delegate() {
    return delegate;
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public static void register(String id, HystrixConcurrencyStrategy strategy) {
	multiConcurrencyStrategyDispatcher.register(id, strategy);
	verifyRegistered();
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public void register(String id, HystrixConcurrencyStrategy strategy) {
	this.strategies.put(MultiConfigId.create(id), strategy);
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public HystrixConcurrencyStrategy getHystrixConcurrencyStrategy() {
	return this.hystrixConcurrencyStrategy;
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public void buildAndRegister() {
    HystrixPlugins plugins = HystrixPlugins.getInstance();

    // memorize the registered plugins
    HystrixCommandExecutionHook commandExecutionHook = plugins.getCommandExecutionHook();
    HystrixEventNotifier eventNotifier = plugins.getEventNotifier();
    HystrixMetricsPublisher metricsPublisher = plugins.getMetricsPublisher();
    HystrixPropertiesStrategy propertiesStrategy = plugins.getPropertiesStrategy();
    HystrixConcurrencyStrategy concurrencyStrategy = plugins.getConcurrencyStrategy();

    HystrixMetricsCollector collector = new HystrixMetricsCollector(namespace,
            new Consumer<Histogram.Builder>() {
                @Override
                public void accept(Histogram.Builder builder) {
                    if (metrics == MetricsType.EXPONENTIAL) {
                        builder.exponentialBuckets(exponentialStart, exponentialFactor, exponentialCount);
                    } else if (metrics == MetricsType.LINEAR) {
                        builder.linearBuckets(linearStart, linearWidth, linearCount);
                    } else if (metrics == MetricsType.DISTINCT) {
                        builder.buckets(distinctBuckets);
                    } else if (metrics == MetricsType.DEFAULT) {
                        // nothing to do
                    } else {
                        throw new IllegalStateException("unknown enum state " + metrics);
                    }
                }
            }).register(registry);

    // wrap the metrics publisher plugin
    HystrixPrometheusMetricsPublisher wrappedMetricsPublisher =
            new HystrixPrometheusMetricsPublisher(exportProperties,
                    exportDeprecatedMetrics, collector, metricsPublisher);

    // reset all plugins
    HystrixPlugins.reset();
    // the following statement wouldn't be necessary, but I'm paranoid that reset might
    // change the plugin instance.
    plugins = HystrixPlugins.getInstance();

    // set previous values for all plugins, but not if they would use the default implementation,
    // as this would block the slot for plugins to be registered.

    // REASON: if there was no previous setting, Hystrix would have returned the default implementation
    // and not all other plugin use the reset-and-wrap approach we do here.

    // ASSUMPTION: the default strategies/hooks can't wrap a different strategy/hook

    // CAVEAT: instead of a default implementation there is a sophisticated Archaius configuration mechanism
    // to determine a class from property settings. There is a corner case where someone would register a
    // default implementation manually overriding an Archaius configuration. Therefore this is configurable
    // using "registerDefaultPlugins".

    if (registerDefaultPlugins || concurrencyStrategy.getClass() != HystrixConcurrencyStrategyDefault.class) {
        plugins.registerConcurrencyStrategy(concurrencyStrategy);
    }
    if (registerDefaultPlugins || commandExecutionHook.getClass() != HystrixCommandExecutionHookDefault.class) {
        plugins.registerCommandExecutionHook(commandExecutionHook);
    }
    if (registerDefaultPlugins || eventNotifier.getClass() != HystrixEventNotifierDefault.class) {
        plugins.registerEventNotifier(eventNotifier);
    }
    if (registerDefaultPlugins || propertiesStrategy.getClass() != HystrixPropertiesStrategyDefault.class) {
        plugins.registerPropertiesStrategy(propertiesStrategy);
    }

    // ... except for the metrics publisher that will now be wrapped
    plugins.registerMetricsPublisher(wrappedMetricsPublisher);
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
public SecurityContextConcurrencyStrategy(
		HystrixConcurrencyStrategy existingConcurrencyStrategy) {
	this.existingConcurrencyStrategy = existingConcurrencyStrategy;
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
@Test
public void testSecurityConcurrencyStrategyInstalled() {
	HystrixConcurrencyStrategy concurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
	assertThat(concurrencyStrategy).isInstanceOf(SecurityContextConcurrencyStrategy.class);
}
 

import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy; //导入依赖的package包/类
void setHystrixConcurrencyStrategy(HystrixConcurrencyStrategy concurrencyStrategy) {
    LOGGER.entering(CLASSNAME, "setHystrixConcurrencyStrategy", concurrencyStrategy);
    HystrixPlugins.getInstance().registerConcurrencyStrategy(concurrencyStrategy);
    LOGGER.exiting(CLASSNAME, "setHystrixConcurrencyStrategy");
}