/// <summary>
/// Waits uninterruptibly for <paramref name="new_value"/> to be loaded.
/// </summary>
/// <param name="key">The key associated with the laoding value.</param>
/// <param name="loading_value_reference"></param>
/// <param name="new_value"></param>
/// <returns></returns>
T GetUninterruptibly(string key,
LoadingValueReference <T> loading_value_reference, IFuture <T> new_value)
{
T value = default(T);
try {
value = Uninterruptibles.GetUninterruptibly(new_value);
// Cache loader should never returns null for reference types.
if (IsNull(value))
{
throw new InvalidCacheLoadException(
"CacheLoader returned a null for key " + key + ".");
}
// TODO(neylor.silva): Record load success stats.
StoreLoadedValue(key, loading_value_reference, value);
return(value);
} finally {
if (IsNull(value))
{
// TODO(neylor.silva): Record load exception stats.
RemoveLoadingValue(key, loading_value_reference);
}
}
}
/// <summary>
/// Run a set of threads making changes to the deprecations
/// concurrently with another set of threads calling get()
/// and set() on Configuration objects.
/// </summary>
/// <exception cref="System.Exception"/>
public virtual void TestConcurrentDeprecateAndManipulate()
{
int NumThreadIds = 10;
int NumKeysPerThread = 1000;
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2 * NumThreadIds
, new ThreadFactoryBuilder().SetDaemon(true).SetNameFormat("testConcurrentDeprecateAndManipulate modification thread %d"
).Build());
CountDownLatch latch = new CountDownLatch(1);
AtomicInteger highestModificationThreadId = new AtomicInteger(1);
IList <Future <Void> > futures = new List <Future <Void> >();
for (int i = 0; i < NumThreadIds; i++)
{
futures.AddItem(executor.Schedule(new _Callable_363(latch, highestModificationThreadId
, NumKeysPerThread), 0, TimeUnit.Seconds));
}
AtomicInteger highestAccessThreadId = new AtomicInteger(1);
for (int i_1 = 0; i_1 < NumThreadIds; i_1++)
{
futures.AddItem(executor.Schedule(new _Callable_382(latch, highestAccessThreadId,
NumKeysPerThread), 0, TimeUnit.Seconds));
}
latch.CountDown();
// allow all threads to proceed
foreach (Future <Void> future in futures)
{
Uninterruptibles.GetUninterruptibly(future);
}
}
public T WaitForValue()
{
return(Uninterruptibles.GetUninterruptibly(this));
}
