@Override public void refresh(K key) { autoDelegate.refresh(key); }
@Override public void refresh(K key) { autoDelegate.refresh(key); }
@Override public void refresh(K key) { delegate().refresh(key); }
@Override public void run() { cache.refresh(key); doneSignal.countDown(); } }.start();
@Override public void run() { cache.refresh(refreshKey); getFinishedSignal.countDown(); } }.start();
@Override public void run() { cache.refresh(refreshKey); getFinishedSignal.countDown(); } }.start();
@Override public void run() { cache.refresh(refreshKey); getFinishedSignal.countDown(); } }.start();
@Override public void run() { cache.refresh(refreshKey); getFinishedSignal.countDown(); } }.start();
@Override public void refresh(K key) { cache.refresh(key); } }
@Override public void refresh(K key) { delegate().refresh(key); }
public NetworkLocation get(HostAddress host) { NetworkLocation location = cache.getIfPresent(host); if ((location == null) && (negativeCache.getIfPresent(host) == null)) { // Store a value in the cache, so that refresh() is done asynchronously cache.put(host, ROOT_LOCATION); cache.refresh(host); } // Return the root location for anything we couldn't locate return location == null ? ROOT_LOCATION : location; }
@Override public void run() { gettersStartedSignal.countDown(); Object value = null; try { int mod = index % 3; if (mod == 0) { value = cache.get(key); } else if (mod == 1) { value = cache.getUnchecked(key); } else { cache.refresh(key); value = cache.get(key); } result.set(index, value); } catch (Throwable t) { result.set(index, t); } gettersComplete.countDown(); } });
expectedComputations++; cache.refresh(1); checkNothingLogged(); ref = new WeakReference<>(map.get(1));
public void testReloadAfterFailure() throws ExecutionException { final AtomicInteger count = new AtomicInteger(); final Exception e = new IllegalStateException("exception to trigger failure on first load()"); CacheLoader<Integer, String> failOnceFunction = new CacheLoader<Integer, String>() { @Override public String load(Integer key) throws Exception { if (count.getAndIncrement() == 0) { throw e; } return key.toString(); } }; CountingRemovalListener<Integer, String> removalListener = countingRemovalListener(); LoadingCache<Integer, String> cache = CacheBuilder.newBuilder().removalListener(removalListener).build(failOnceFunction); try { cache.getUnchecked(1); fail(); } catch (UncheckedExecutionException ue) { assertThat(ue).hasCauseThat().isSameAs(e); } assertEquals("1", cache.getUnchecked(1)); assertEquals(0, removalListener.getCount()); count.set(0); cache.refresh(2); checkLoggedCause(e); assertEquals("2", cache.getUnchecked(2)); assertEquals(0, removalListener.getCount()); }
public void testReload_interrupted() { try { LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build( Caffeine.newBuilder().executor(MoreExecutors.directExecutor()), new CacheLoader<Integer, Integer>() { @Override public Integer load(Integer key) throws Exception { throw new InterruptedException(); } }); cache.put(1, 1); cache.refresh(1); } catch (CacheLoaderException e) { assertTrue(Thread.currentThread().isInterrupted()); } }
public void testReloadAfterSimulatedKeyReclamation() throws ExecutionException { CountingLoader countingLoader = new CountingLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().concurrencyLevel(1).weakKeys().build(countingLoader); Object key = new Object(); assertNotNull(cache.getUnchecked(key)); assertEquals(1, cache.size()); CacheTesting.simulateKeyReclamation(cache, key); // this blocks if computation can't deal with partially-collected values assertNotNull(cache.getUnchecked(key)); assertEquals(2, countingLoader.getCount()); CacheTesting.simulateKeyReclamation(cache, key); cache.refresh(key); checkNothingLogged(); assertEquals(3, countingLoader.getCount()); }
public void testReloadAfterSimulatedValueReclamation() throws ExecutionException { CountingLoader countingLoader = new CountingLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().concurrencyLevel(1).weakValues().build(countingLoader); Object key = new Object(); assertNotNull(cache.getUnchecked(key)); CacheTesting.simulateValueReclamation(cache, key); // this blocks if computation can't deal with partially-collected values assertNotNull(cache.getUnchecked(key)); assertEquals(1, cache.size()); assertEquals(2, countingLoader.getCount()); CacheTesting.simulateValueReclamation(cache, key); cache.refresh(key); checkNothingLogged(); assertEquals(1, cache.size()); assertEquals(3, countingLoader.getCount()); }
assertEquals(0, stats.hitCount()); cache.refresh(key); checkLoggedInvalidLoad(); stats = cache.stats();