@Override public <K extends Serializable, V extends Serializable> Cache<K, V> getCache(String cacheName) { Cache<K, V> cache = CacheBuilder.newBuilder() .weakValues() .concurrencyLevel(DEFAULT_CONCURRENCY_LEVEL) .expireAfterAccess(DEFAULT_EXPIRATION_MINUTES, TimeUnit.MINUTES) .maximumSize(DEFAULT_MAX_ENTRIES) .build(); return cache; }
break; case WEAK: builder.weakValues(); break; default:
@Test public void foo() { Cache<Object, Object> build = CacheBuilder.newBuilder().maximumSize(1).weakValues().removalListener(new RemovalListener<Object, Object>() { @Override public void onRemoval(RemovalNotification<Object, Object> notification) { System.out.println(notification.getCause()); } }).build(); build.put(1, 1); build.put(1, 2); build.put(2, 2); } }
CacheBuilder.newBuilder().weakKeys().weakValues().build(recursiveLoader); cacheRef.set(recursiveCache); assertEquals("3, 2, 1, 0", recursiveCache.getUnchecked(3)); recursiveCache = CacheBuilder.newBuilder().weakKeys().weakValues().build(recursiveLoader); cacheRef.set(recursiveCache);
public void testCacheBuilderFrom_string() { CacheBuilder<?, ?> fromString = CacheBuilder.from( "initialCapacity=10,maximumSize=20,concurrencyLevel=30," + "weakKeys,weakValues,expireAfterAccess=10m"); CacheBuilder<?, ?> expected = CacheBuilder.newBuilder() .initialCapacity(10) .maximumSize(20) .concurrencyLevel(30) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES); assertCacheBuilderEquivalence(expected, fromString); }
break; case WEAK: builder.weakValues(); break; default:
public void testReloadAfterValueReclamation() throws InterruptedException, ExecutionException { CountingLoader countingLoader = new CountingLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().weakValues().build(countingLoader); ConcurrentMap<Object, Object> map = cache.asMap();
@GwtIncompatible // weakValues public void testValueStrengthSetTwice() { CacheBuilder<Object, Object> builder1 = CacheBuilder.newBuilder().weakValues(); try { builder1.weakValues(); fail(); } catch (IllegalStateException expected) { } try { builder1.softValues(); fail(); } catch (IllegalStateException expected) { } CacheBuilder<Object, Object> builder2 = CacheBuilder.newBuilder().softValues(); try { builder2.softValues(); fail(); } catch (IllegalStateException expected) { } try { builder2.weakValues(); fail(); } catch (IllegalStateException expected) { } }
break; case WEAK: builder.weakValues(); break; default:
public void testSetWeakValues() { LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakValues()); checkStrength(map, Strength.STRONG, Strength.WEAK); assertSame(EntryFactory.STRONG, map.entryFactory); }
DataSize maxQuerySpillPerNode = nodeSpillConfig.getQueryMaxSpillPerNode(); queryContexts = CacheBuilder.newBuilder().weakValues().build(CacheLoader.from( queryId -> createQueryContext(queryId, localMemoryManager, nodeMemoryConfig, localSpillManager, gcMonitor, maxQueryUserMemoryPerNode, maxQueryTotalMemoryPerNode, maxQuerySpillPerNode)));
/** Returns an iterable containing all combinations weakKeys and weak/softValues. */ @SuppressWarnings("unchecked") // varargs private static Iterable<CacheBuilder<Object, Object>> allKeyValueStrengthMakers() { return ImmutableList.of( createCacheBuilder(), createCacheBuilder().weakValues(), createCacheBuilder().softValues(), createCacheBuilder().weakKeys(), createCacheBuilder().weakKeys().weakValues(), createCacheBuilder().weakKeys().softValues()); }
public void testParse_multipleKeys() { CacheBuilderSpec spec = parse( "initialCapacity=10,maximumSize=20,concurrencyLevel=30," + "weakKeys,weakValues,expireAfterAccess=10m,expireAfterWrite=1h"); assertEquals(10, spec.initialCapacity.intValue()); assertEquals(20, spec.maximumSize.intValue()); assertNull(spec.maximumWeight); assertEquals(30, spec.concurrencyLevel.intValue()); assertEquals(Strength.WEAK, spec.keyStrength); assertEquals(Strength.WEAK, spec.valueStrength); assertEquals(TimeUnit.HOURS, spec.writeExpirationTimeUnit); assertEquals(TimeUnit.MINUTES, spec.accessExpirationTimeUnit); assertEquals(1L, spec.writeExpirationDuration); assertEquals(10L, spec.accessExpirationDuration); CacheBuilder<?, ?> expected = CacheBuilder.newBuilder() .initialCapacity(10) .maximumSize(20) .concurrencyLevel(30) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES) .expireAfterWrite(1L, TimeUnit.HOURS); assertCacheBuilderEquivalence(expected, CacheBuilder.from(spec)); }
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()); }
public void testParse_weakValues() { CacheBuilderSpec spec = parse("weakValues"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertEquals(Strength.WEAK, spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().weakValues(), CacheBuilder.from(spec)); }
public LockCollection() { locksById = CacheBuilder.newBuilder() .weakValues() .build(new CacheLoader<LockDescriptor, ExclusiveLock>() { @Override public ExclusiveLock load(LockDescriptor descriptor) throws Exception { return new ExclusiveLock(descriptor); } }); }
builder.weakValues(); } else if (context.valueStrength == ReferenceType.SOFT) { builder.softValues();
.createTestSuite()); suite.addTest( MapTestSuiteBuilder.using(new TestStringCacheGenerator(createCacheBuilder().weakValues())) .named("LocalCache with weakValues") // values are string literals and won't be GC'd .withFeatures(
private synchronized static CompositePublicInfo getPublicInfo(Class<?> typeClass) { if (classInfoCache == null) { classInfoCache = CacheBuilder.newBuilder().weakValues().build( new CacheLoader<Class<?>, CompositePublicInfo>() { @Override public CompositePublicInfo load(Class<?> aClass) throws Exception { return readPublicFields(aClass); } }); } return classInfoCache.getUnchecked(typeClass); }
@Override public LoadingCache<String, Class<?>> load(final ClassLoader classloader) { return CacheBuilder.newBuilder().weakValues().build(new CacheLoader<String, Class<?>>() { @Override public Class<?> load(String fullQualifiedName) throws ClassNotFoundException { return Class.forName(fullQualifiedName, false, classloader); } }); }