protected virtual IThreadPool NewThreadPool(int queueCapacity)
{
IBuilder Builder = ThreadPools.NewThreadPoolConfigBuilder();
Builder.SetMinSize(_minSize).SetMaxSize(_maxSize).SetQueueCapacity(queueCapacity);
return(ThreadPools.NewThreadPool(Builder.Build()));
}
protected override void Init()
{
base.Init();
_taskScheduler = new Thread(AutoCheck)
{
IsBackground = true
};
_taskScheduler.Start();
_scaleOutTask = () =>
{
try
{
TryAddNewEntry(Config.ScaleFactor - 1);
_logger.Info("scaleOut success");
}
catch (Exception ex)
{
_logger.Error(ex, "scaleOut failed");
}
finally
{
Interlocked.CompareExchange(ref _scalingOut, 1, 0);
}
};
ThreadPool.IBuilder builder = ThreadPools.NewThreadPoolConfigBuilder();
builder.SetMinSize(1).SetMaxSize(1);
_taskExecutor = ThreadPools.NewThreadPool(builder.Build());
}
internal static IHystrixThreadPool GetInstance(IHystrixThreadPoolKey threadPoolKey, IHystrixThreadPoolOptions propertiesBuilder)
{
// get the key to use instead of using the object itself so that if people forget to implement equals/hashcode things will still work
var key = threadPoolKey.Name;
// if we get here this is the first time so we need to initialize
return(ThreadPools.GetOrAddEx(key, (k) => new HystrixThreadPoolDefault(threadPoolKey, propertiesBuilder)));
}
private static void ThreadPoolExample()
{
var threadPool = new ThreadPools();
threadPool.Run();
Console.ReadKey();
}
public void Add(EoiThread thread)
{
lock (ThreadPools)
{
if (!ThreadPools.ContainsKey(thread.ThreadPool))
{
ThreadPools.Add(thread.ThreadPool, new EoiThreadPool());
}
ThreadPools[thread.ThreadPool].WaitingThreads.AddLast(thread);
}
}
protected virtual IThreadPool NewThreadPool(long checkInterval, long maxIdleTime, long ttl, int queueCapacity)
{
ThreadPool.AutoScale.IBuilder builder = ThreadPools.NewAutoScaleThreadPoolConfigBuilder();
builder.SetMinSize(_minSize).SetMaxSize(_maxSize).SetScaleFactor(5).SetCheckInterval(checkInterval)
.SetMaxIdleTime(maxIdleTime).SetQueueCapacity(queueCapacity);
_objectTtl = ttl;
try
{
return(new TestAutoScaleThreadPool(builder.Build()));
}
finally
{
_objectTtl = long.MaxValue;
}
}
protected override void Test(IQuantileEstimator <int> quantileEstimator, List <Double> quantiles, int count, int upperBound,
double errorRate, Func <int, int, List <int> > dataProvider)
{
int maxError = (int)(upperBound * errorRate);
List <int> items = dataProvider(count, upperBound);
int concurrency = 20;
IBuilder builder = ThreadPools.NewThreadPoolConfigBuilder();
using (IThreadPool threadPool = ThreadPools.NewThreadPool(builder.SetMaxSize(concurrency).SetMinSize(concurrency).Build()))
{
object @lock = new object();
CountdownEvent latch = new CountdownEvent(concurrency);
for (int i = 0; i < concurrency; i++)
{
threadPool.Submit(() =>
{
lock (@lock)
{
Monitor.Wait(@lock);
}
items.ForEach(item => quantileEstimator.Add(item));
quantileEstimator.Get(quantiles);
latch.Signal();
});
}
Thread.Sleep(1 * 1000);
lock (@lock)
{
Monitor.PulseAll(@lock);
}
latch.Wait();
}
Console.WriteLine("data: " + items);
Console.WriteLine();
items.Sort();
Console.WriteLine("sorted: " + items);
Console.WriteLine();
Dictionary <Double, int> quantileResults = new Dictionary <Double, int>();
foreach (Double quantile in quantiles)
{
int pos = (int)(count * quantile) - 1;
if (pos < 0)
{
pos = 0;
}
int item = items[pos];
quantileEstimator.Add(item);
quantileResults[quantile] = item;
}
Dictionary <Double, int> results = quantileEstimator.Get(quantiles);
for (int i = 0; i < quantiles.Count; i++)
{
Double quantile = quantiles[i];
int expected = quantileResults[quantile];
int actual = results[quantile];
int actualError = Math.Abs(actual - expected);
Console.WriteLine("quantile " + quantile + ", expected: " + expected + ", actual: " + actual + ", error: "
+ actualError);
Console.WriteLine();
Assert.True(actualError <= maxError);
}
}
