001/* 002 * Copyright (C) 2009 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.cache; 016 017import static com.google.common.base.Preconditions.checkArgument; 018import static com.google.common.base.Preconditions.checkNotNull; 019import static com.google.common.base.Preconditions.checkState; 020 021import com.google.common.annotations.GwtCompatible; 022import com.google.common.annotations.GwtIncompatible; 023import com.google.common.base.Ascii; 024import com.google.common.base.Equivalence; 025import com.google.common.base.MoreObjects; 026import com.google.common.base.Supplier; 027import com.google.common.base.Suppliers; 028import com.google.common.base.Ticker; 029import com.google.common.cache.AbstractCache.SimpleStatsCounter; 030import com.google.common.cache.AbstractCache.StatsCounter; 031import com.google.common.cache.LocalCache.Strength; 032import com.google.errorprone.annotations.CheckReturnValue; 033import com.google.j2objc.annotations.J2ObjCIncompatible; 034import java.util.ConcurrentModificationException; 035import java.util.IdentityHashMap; 036import java.util.Map; 037import java.util.concurrent.ConcurrentHashMap; 038import java.util.concurrent.TimeUnit; 039import java.util.logging.Level; 040import java.util.logging.Logger; 041import org.checkerframework.checker.nullness.qual.Nullable; 042 043/** 044 * A builder of {@link LoadingCache} and {@link Cache} instances. 045 * 046 * <h2>Prefer <a href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a> over Guava's caching 047 * API</h2> 048 * 049 * <p>The successor to Guava's caching API is <a 050 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a 051 * nearly drop-in replacement -- though it requires Java 8 APIs, is not available for Android or 052 * GWT/j2cl, and may have <a href="https://github.com/ben-manes/caffeine/wiki/Guava">different 053 * (usually better) behavior</a> when multiple threads attempt concurrent mutations. Its equivalent 054 * to {@code CacheBuilder} is its <a 055 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/Caffeine.html">{@code 056 * Caffeine}</a> class. Caffeine offers better performance, more features (including asynchronous 057 * loading), and fewer <a 058 * href="https://github.com/google/guava/issues?q=is%3Aopen+is%3Aissue+label%3Apackage%3Dcache+label%3Atype%3Ddefect">bugs</a>. 059 * 060 * <p>Caffeine defines its own interfaces (<a 061 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/Cache.html">{@code 062 * Cache}</a>, <a 063 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/LoadingCache.html">{@code 064 * LoadingCache}</a>, <a 065 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/CacheLoader.html">{@code 066 * CacheLoader}</a>, etc.), so you can use Caffeine without needing to use any Guava types. 067 * Caffeine's types are better than Guava's, especially for <a 068 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncLoadingCache.html">their 069 * deep support for asynchronous operations</a>. But if you want to migrate to Caffeine with minimal 070 * code changes, you can use <a 071 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/guava/latest/com.github.benmanes.caffeine.guava/com/github/benmanes/caffeine/guava/CaffeinatedGuava.html">its 072 * {@code CaffeinatedGuava} adapter class</a>, which lets you build a Guava {@code Cache} or a Guava 073 * {@code LoadingCache} backed by a Guava {@code CacheLoader}. 074 * 075 * <p>Caffeine's API for asynchronous operations uses {@code CompletableFuture}: <a 076 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncLoadingCache.html#get(K)">{@code 077 * AsyncLoadingCache.get}</a> returns a {@code CompletableFuture}, and implementations of <a 078 * href="https://www.javadoc.io/doc/com.github.ben-manes.caffeine/caffeine/latest/com.github.benmanes.caffeine/com/github/benmanes/caffeine/cache/AsyncCacheLoader.html#asyncLoad(K,java.util.concurrent.Executor)">{@code 079 * AsyncCacheLoader.asyncLoad}</a> must return a {@code CompletableFuture}. Users of Guava's {@link 080 * com.google.common.util.concurrent.ListenableFuture} can adapt between the two {@code Future} 081 * types by using <a href="https://github.com/lukas-krecan/future-converter#java8-guava">{@code 082 * net.javacrumbs.futureconverter.java8guava.FutureConverter}</a>. 083 * 084 * <h2>More on {@code CacheBuilder}</h2> 085 * 086 * {@code CacheBuilder} builds caches with any combination of the following features: 087 * 088 * <ul> 089 * <li>automatic loading of entries into the cache 090 * <li>least-recently-used eviction when a maximum size is exceeded (note that the cache is 091 * divided into segments, each of which does LRU internally) 092 * <li>time-based expiration of entries, measured since last access or last write 093 * <li>keys automatically wrapped in {@code WeakReference} 094 * <li>values automatically wrapped in {@code WeakReference} or {@code SoftReference} 095 * <li>notification of evicted (or otherwise removed) entries 096 * <li>accumulation of cache access statistics 097 * </ul> 098 * 099 * <p>These features are all optional; caches can be created using all or none of them. By default 100 * cache instances created by {@code CacheBuilder} will not perform any type of eviction. 101 * 102 * <p>Usage example: 103 * 104 * <pre>{@code 105 * LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder() 106 * .maximumSize(10000) 107 * .expireAfterWrite(Duration.ofMinutes(10)) 108 * .removalListener(MY_LISTENER) 109 * .build( 110 * new CacheLoader<Key, Graph>() { 111 * public Graph load(Key key) throws AnyException { 112 * return createExpensiveGraph(key); 113 * } 114 * }); 115 * }</pre> 116 * 117 * <p>Or equivalently, 118 * 119 * <pre>{@code 120 * // In real life this would come from a command-line flag or config file 121 * String spec = "maximumSize=10000,expireAfterWrite=10m"; 122 * 123 * LoadingCache<Key, Graph> graphs = CacheBuilder.from(spec) 124 * .removalListener(MY_LISTENER) 125 * .build( 126 * new CacheLoader<Key, Graph>() { 127 * public Graph load(Key key) throws AnyException { 128 * return createExpensiveGraph(key); 129 * } 130 * }); 131 * }</pre> 132 * 133 * <p>The returned cache is implemented as a hash table with similar performance characteristics to 134 * {@link ConcurrentHashMap}. It implements all optional operations of the {@link LoadingCache} and 135 * {@link Cache} interfaces. The {@code asMap} view (and its collection views) have <i>weakly 136 * consistent iterators</i>. This means that they are safe for concurrent use, but if other threads 137 * modify the cache after the iterator is created, it is undefined which of these changes, if any, 138 * are reflected in that iterator. These iterators never throw {@link 139 * ConcurrentModificationException}. 140 * 141 * <p><b>Note:</b> by default, the returned cache uses equality comparisons (the {@link 142 * Object#equals equals} method) to determine equality for keys or values. However, if {@link 143 * #weakKeys} was specified, the cache uses identity ({@code ==}) comparisons instead for keys. 144 * Likewise, if {@link #weakValues} or {@link #softValues} was specified, the cache uses identity 145 * comparisons for values. 146 * 147 * <p>Entries are automatically evicted from the cache when any of {@linkplain #maximumSize(long) 148 * maximumSize}, {@linkplain #maximumWeight(long) maximumWeight}, {@linkplain #expireAfterWrite 149 * expireAfterWrite}, {@linkplain #expireAfterAccess expireAfterAccess}, {@linkplain #weakKeys 150 * weakKeys}, {@linkplain #weakValues weakValues}, or {@linkplain #softValues softValues} are 151 * requested. 152 * 153 * <p>If {@linkplain #maximumSize(long) maximumSize} or {@linkplain #maximumWeight(long) 154 * maximumWeight} is requested entries may be evicted on each cache modification. 155 * 156 * <p>If {@linkplain #expireAfterWrite expireAfterWrite} or {@linkplain #expireAfterAccess 157 * expireAfterAccess} is requested entries may be evicted on each cache modification, on occasional 158 * cache accesses, or on calls to {@link Cache#cleanUp}. Expired entries may be counted by {@link 159 * Cache#size}, but will never be visible to read or write operations. 160 * 161 * <p>If {@linkplain #weakKeys weakKeys}, {@linkplain #weakValues weakValues}, or {@linkplain 162 * #softValues softValues} are requested, it is possible for a key or value present in the cache to 163 * be reclaimed by the garbage collector. Entries with reclaimed keys or values may be removed from 164 * the cache on each cache modification, on occasional cache accesses, or on calls to {@link 165 * Cache#cleanUp}; such entries may be counted in {@link Cache#size}, but will never be visible to 166 * read or write operations. 167 * 168 * <p>Certain cache configurations will result in the accrual of periodic maintenance tasks which 169 * will be performed during write operations, or during occasional read operations in the absence of 170 * writes. The {@link Cache#cleanUp} method of the returned cache will also perform maintenance, but 171 * calling it should not be necessary with a high throughput cache. Only caches built with 172 * {@linkplain #removalListener removalListener}, {@linkplain #expireAfterWrite expireAfterWrite}, 173 * {@linkplain #expireAfterAccess expireAfterAccess}, {@linkplain #weakKeys weakKeys}, {@linkplain 174 * #weakValues weakValues}, or {@linkplain #softValues softValues} perform periodic maintenance. 175 * 176 * <p>The caches produced by {@code CacheBuilder} are serializable, and the deserialized caches 177 * retain all the configuration properties of the original cache. Note that the serialized form does 178 * <i>not</i> include cache contents, but only configuration. 179 * 180 * <p>See the Guava User Guide article on <a 181 * href="https://github.com/google/guava/wiki/CachesExplained">caching</a> for a higher-level 182 * explanation. 183 * 184 * @param <K> the most general key type this builder will be able to create caches for. This is 185 * normally {@code Object} unless it is constrained by using a method like {@code 186 * #removalListener}. Cache keys may not be null. 187 * @param <V> the most general value type this builder will be able to create caches for. This is 188 * normally {@code Object} unless it is constrained by using a method like {@code 189 * #removalListener}. Cache values may not be null. 190 * @author Charles Fry 191 * @author Kevin Bourrillion 192 * @since 10.0 193 */ 194@GwtCompatible(emulated = true) 195@ElementTypesAreNonnullByDefault 196public final class CacheBuilder<K, V> { 197 private static final int DEFAULT_INITIAL_CAPACITY = 16; 198 private static final int DEFAULT_CONCURRENCY_LEVEL = 4; 199 200 @SuppressWarnings("GoodTime") // should be a java.time.Duration 201 private static final int DEFAULT_EXPIRATION_NANOS = 0; 202 203 @SuppressWarnings("GoodTime") // should be a java.time.Duration 204 private static final int DEFAULT_REFRESH_NANOS = 0; 205 206 static final Supplier<? extends StatsCounter> NULL_STATS_COUNTER = 207 Suppliers.ofInstance( 208 new StatsCounter() { 209 @Override 210 public void recordHits(int count) {} 211 212 @Override 213 public void recordMisses(int count) {} 214 215 @SuppressWarnings("GoodTime") // b/122668874 216 @Override 217 public void recordLoadSuccess(long loadTime) {} 218 219 @SuppressWarnings("GoodTime") // b/122668874 220 @Override 221 public void recordLoadException(long loadTime) {} 222 223 @Override 224 public void recordEviction() {} 225 226 @Override 227 public CacheStats snapshot() { 228 return EMPTY_STATS; 229 } 230 }); 231 static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0); 232 233 static final Supplier<StatsCounter> CACHE_STATS_COUNTER = 234 new Supplier<StatsCounter>() { 235 @Override 236 public StatsCounter get() { 237 return new SimpleStatsCounter(); 238 } 239 }; 240 241 enum NullListener implements RemovalListener<Object, Object> { 242 INSTANCE; 243 244 @Override 245 public void onRemoval(RemovalNotification<Object, Object> notification) {} 246 } 247 248 enum OneWeigher implements Weigher<Object, Object> { 249 INSTANCE; 250 251 @Override 252 public int weigh(Object key, Object value) { 253 return 1; 254 } 255 } 256 257 static final Ticker NULL_TICKER = 258 new Ticker() { 259 @Override 260 public long read() { 261 return 0; 262 } 263 }; 264 265 private static final Logger logger = Logger.getLogger(CacheBuilder.class.getName()); 266 267 static final int UNSET_INT = -1; 268 269 boolean strictParsing = true; 270 271 int initialCapacity = UNSET_INT; 272 int concurrencyLevel = UNSET_INT; 273 long maximumSize = UNSET_INT; 274 long maximumWeight = UNSET_INT; 275 @Nullable Weigher<? super K, ? super V> weigher; 276 277 @Nullable Strength keyStrength; 278 @Nullable Strength valueStrength; 279 280 @SuppressWarnings("GoodTime") // should be a java.time.Duration 281 long expireAfterWriteNanos = UNSET_INT; 282 283 @SuppressWarnings("GoodTime") // should be a java.time.Duration 284 long expireAfterAccessNanos = UNSET_INT; 285 286 @SuppressWarnings("GoodTime") // should be a java.time.Duration 287 long refreshNanos = UNSET_INT; 288 289 @Nullable Equivalence<Object> keyEquivalence; 290 @Nullable Equivalence<Object> valueEquivalence; 291 292 @Nullable RemovalListener<? super K, ? super V> removalListener; 293 @Nullable Ticker ticker; 294 295 Supplier<? extends StatsCounter> statsCounterSupplier = NULL_STATS_COUNTER; 296 297 private CacheBuilder() {} 298 299 /** 300 * Constructs a new {@code CacheBuilder} instance with default settings, including strong keys, 301 * strong values, and no automatic eviction of any kind. 302 * 303 * <p>Note that while this return type is {@code CacheBuilder<Object, Object>}, type parameters on 304 * the {@link #build} methods allow you to create a cache of any key and value type desired. 305 */ 306 @CheckReturnValue 307 public static CacheBuilder<Object, Object> newBuilder() { 308 return new CacheBuilder<>(); 309 } 310 311 /** 312 * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}. 313 * 314 * @since 12.0 315 */ 316 @GwtIncompatible // To be supported 317 @CheckReturnValue 318 public static CacheBuilder<Object, Object> from(CacheBuilderSpec spec) { 319 return spec.toCacheBuilder().lenientParsing(); 320 } 321 322 /** 323 * Constructs a new {@code CacheBuilder} instance with the settings specified in {@code spec}. 324 * This is especially useful for command-line configuration of a {@code CacheBuilder}. 325 * 326 * @param spec a String in the format specified by {@link CacheBuilderSpec} 327 * @since 12.0 328 */ 329 @GwtIncompatible // To be supported 330 @CheckReturnValue 331 public static CacheBuilder<Object, Object> from(String spec) { 332 return from(CacheBuilderSpec.parse(spec)); 333 } 334 335 /** 336 * Enables lenient parsing. Useful for tests and spec parsing. 337 * 338 * @return this {@code CacheBuilder} instance (for chaining) 339 */ 340 @GwtIncompatible // To be supported 341 CacheBuilder<K, V> lenientParsing() { 342 strictParsing = false; 343 return this; 344 } 345 346 /** 347 * Sets a custom {@code Equivalence} strategy for comparing keys. 348 * 349 * <p>By default, the cache uses {@link Equivalence#identity} to determine key equality when 350 * {@link #weakKeys} is specified, and {@link Equivalence#equals()} otherwise. 351 * 352 * @return this {@code CacheBuilder} instance (for chaining) 353 */ 354 @GwtIncompatible // To be supported 355 CacheBuilder<K, V> keyEquivalence(Equivalence<Object> equivalence) { 356 checkState(keyEquivalence == null, "key equivalence was already set to %s", keyEquivalence); 357 keyEquivalence = checkNotNull(equivalence); 358 return this; 359 } 360 361 Equivalence<Object> getKeyEquivalence() { 362 return MoreObjects.firstNonNull(keyEquivalence, getKeyStrength().defaultEquivalence()); 363 } 364 365 /** 366 * Sets a custom {@code Equivalence} strategy for comparing values. 367 * 368 * <p>By default, the cache uses {@link Equivalence#identity} to determine value equality when 369 * {@link #weakValues} or {@link #softValues} is specified, and {@link Equivalence#equals()} 370 * otherwise. 371 * 372 * @return this {@code CacheBuilder} instance (for chaining) 373 */ 374 @GwtIncompatible // To be supported 375 CacheBuilder<K, V> valueEquivalence(Equivalence<Object> equivalence) { 376 checkState( 377 valueEquivalence == null, "value equivalence was already set to %s", valueEquivalence); 378 this.valueEquivalence = checkNotNull(equivalence); 379 return this; 380 } 381 382 Equivalence<Object> getValueEquivalence() { 383 return MoreObjects.firstNonNull(valueEquivalence, getValueStrength().defaultEquivalence()); 384 } 385 386 /** 387 * Sets the minimum total size for the internal hash tables. For example, if the initial capacity 388 * is {@code 60}, and the concurrency level is {@code 8}, then eight segments are created, each 389 * having a hash table of size eight. Providing a large enough estimate at construction time 390 * avoids the need for expensive resizing operations later, but setting this value unnecessarily 391 * high wastes memory. 392 * 393 * @return this {@code CacheBuilder} instance (for chaining) 394 * @throws IllegalArgumentException if {@code initialCapacity} is negative 395 * @throws IllegalStateException if an initial capacity was already set 396 */ 397 public CacheBuilder<K, V> initialCapacity(int initialCapacity) { 398 checkState( 399 this.initialCapacity == UNSET_INT, 400 "initial capacity was already set to %s", 401 this.initialCapacity); 402 checkArgument(initialCapacity >= 0); 403 this.initialCapacity = initialCapacity; 404 return this; 405 } 406 407 int getInitialCapacity() { 408 return (initialCapacity == UNSET_INT) ? DEFAULT_INITIAL_CAPACITY : initialCapacity; 409 } 410 411 /** 412 * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The 413 * table is internally partitioned to try to permit the indicated number of concurrent updates 414 * without contention. Because assignment of entries to these partitions is not necessarily 415 * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to 416 * accommodate as many threads as will ever concurrently modify the table. Using a significantly 417 * higher value than you need can waste space and time, and a significantly lower value can lead 418 * to thread contention. But overestimates and underestimates within an order of magnitude do not 419 * usually have much noticeable impact. A value of one permits only one thread to modify the cache 420 * at a time, but since read operations and cache loading computations can proceed concurrently, 421 * this still yields higher concurrency than full synchronization. 422 * 423 * <p>Defaults to 4. <b>Note:</b>The default may change in the future. If you care about this 424 * value, you should always choose it explicitly. 425 * 426 * <p>The current implementation uses the concurrency level to create a fixed number of hashtable 427 * segments, each governed by its own write lock. The segment lock is taken once for each explicit 428 * write, and twice for each cache loading computation (once prior to loading the new value, and 429 * once after loading completes). Much internal cache management is performed at the segment 430 * granularity. For example, access queues and write queues are kept per segment when they are 431 * required by the selected eviction algorithm. As such, when writing unit tests it is not 432 * uncommon to specify {@code concurrencyLevel(1)} in order to achieve more deterministic eviction 433 * behavior. 434 * 435 * <p>Note that future implementations may abandon segment locking in favor of more advanced 436 * concurrency controls. 437 * 438 * @return this {@code CacheBuilder} instance (for chaining) 439 * @throws IllegalArgumentException if {@code concurrencyLevel} is nonpositive 440 * @throws IllegalStateException if a concurrency level was already set 441 */ 442 public CacheBuilder<K, V> concurrencyLevel(int concurrencyLevel) { 443 checkState( 444 this.concurrencyLevel == UNSET_INT, 445 "concurrency level was already set to %s", 446 this.concurrencyLevel); 447 checkArgument(concurrencyLevel > 0); 448 this.concurrencyLevel = concurrencyLevel; 449 return this; 450 } 451 452 int getConcurrencyLevel() { 453 return (concurrencyLevel == UNSET_INT) ? DEFAULT_CONCURRENCY_LEVEL : concurrencyLevel; 454 } 455 456 /** 457 * Specifies the maximum number of entries the cache may contain. 458 * 459 * <p>Note that the cache <b>may evict an entry before this limit is exceeded</b>. For example, in 460 * the current implementation, when {@code concurrencyLevel} is greater than {@code 1}, each 461 * resulting segment inside the cache <i>independently</i> limits its own size to approximately 462 * {@code maximumSize / concurrencyLevel}. 463 * 464 * <p>When eviction is necessary, the cache evicts entries that are less likely to be used again. 465 * For example, the cache may evict an entry because it hasn't been used recently or very often. 466 * 467 * <p>If {@code maximumSize} is zero, elements will be evicted immediately after being loaded into 468 * cache. This can be useful in testing, or to disable caching temporarily. 469 * 470 * <p>This feature cannot be used in conjunction with {@link #maximumWeight}. 471 * 472 * @param maximumSize the maximum size of the cache 473 * @return this {@code CacheBuilder} instance (for chaining) 474 * @throws IllegalArgumentException if {@code maximumSize} is negative 475 * @throws IllegalStateException if a maximum size or weight was already set 476 */ 477 public CacheBuilder<K, V> maximumSize(long maximumSize) { 478 checkState( 479 this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize); 480 checkState( 481 this.maximumWeight == UNSET_INT, 482 "maximum weight was already set to %s", 483 this.maximumWeight); 484 checkState(this.weigher == null, "maximum size can not be combined with weigher"); 485 checkArgument(maximumSize >= 0, "maximum size must not be negative"); 486 this.maximumSize = maximumSize; 487 return this; 488 } 489 490 /** 491 * Specifies the maximum weight of entries the cache may contain. Weight is determined using the 492 * {@link Weigher} specified with {@link #weigher}, and use of this method requires a 493 * corresponding call to {@link #weigher} prior to calling {@link #build}. 494 * 495 * <p>Note that the cache <b>may evict an entry before this limit is exceeded</b>. For example, in 496 * the current implementation, when {@code concurrencyLevel} is greater than {@code 1}, each 497 * resulting segment inside the cache <i>independently</i> limits its own weight to approximately 498 * {@code maximumWeight / concurrencyLevel}. 499 * 500 * <p>When eviction is necessary, the cache evicts entries that are less likely to be used again. 501 * For example, the cache may evict an entry because it hasn't been used recently or very often. 502 * 503 * <p>If {@code maximumWeight} is zero, elements will be evicted immediately after being loaded 504 * into cache. This can be useful in testing, or to disable caching temporarily. 505 * 506 * <p>Note that weight is only used to determine whether the cache is over capacity; it has no 507 * effect on selecting which entry should be evicted next. 508 * 509 * <p>This feature cannot be used in conjunction with {@link #maximumSize}. 510 * 511 * @param maximumWeight the maximum total weight of entries the cache may contain 512 * @return this {@code CacheBuilder} instance (for chaining) 513 * @throws IllegalArgumentException if {@code maximumWeight} is negative 514 * @throws IllegalStateException if a maximum weight or size was already set 515 * @since 11.0 516 */ 517 @GwtIncompatible // To be supported 518 public CacheBuilder<K, V> maximumWeight(long maximumWeight) { 519 checkState( 520 this.maximumWeight == UNSET_INT, 521 "maximum weight was already set to %s", 522 this.maximumWeight); 523 checkState( 524 this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize); 525 checkArgument(maximumWeight >= 0, "maximum weight must not be negative"); 526 this.maximumWeight = maximumWeight; 527 return this; 528 } 529 530 /** 531 * Specifies the weigher to use in determining the weight of entries. Entry weight is taken into 532 * consideration by {@link #maximumWeight(long)} when determining which entries to evict, and use 533 * of this method requires a corresponding call to {@link #maximumWeight(long)} prior to calling 534 * {@link #build}. Weights are measured and recorded when entries are inserted into the cache, and 535 * are thus effectively static during the lifetime of a cache entry. 536 * 537 * <p>When the weight of an entry is zero it will not be considered for size-based eviction 538 * (though it still may be evicted by other means). 539 * 540 * <p><b>Important note:</b> Instead of returning <em>this</em> as a {@code CacheBuilder} 541 * instance, this method returns {@code CacheBuilder<K1, V1>}. From this point on, either the 542 * original reference or the returned reference may be used to complete configuration and build 543 * the cache, but only the "generic" one is type-safe. That is, it will properly prevent you from 544 * building caches whose key or value types are incompatible with the types accepted by the 545 * weigher already provided; the {@code CacheBuilder} type cannot do this. For best results, 546 * simply use the standard method-chaining idiom, as illustrated in the documentation at top, 547 * configuring a {@code CacheBuilder} and building your {@link Cache} all in a single statement. 548 * 549 * <p><b>Warning:</b> if you ignore the above advice, and use this {@code CacheBuilder} to build a 550 * cache whose key or value type is incompatible with the weigher, you will likely experience a 551 * {@link ClassCastException} at some <i>undefined</i> point in the future. 552 * 553 * @param weigher the weigher to use in calculating the weight of cache entries 554 * @return this {@code CacheBuilder} instance (for chaining) 555 * @throws IllegalArgumentException if {@code size} is negative 556 * @throws IllegalStateException if a maximum size was already set 557 * @since 11.0 558 */ 559 @GwtIncompatible // To be supported 560 public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> weigher( 561 Weigher<? super K1, ? super V1> weigher) { 562 checkState(this.weigher == null); 563 if (strictParsing) { 564 checkState( 565 this.maximumSize == UNSET_INT, 566 "weigher can not be combined with maximum size", 567 this.maximumSize); 568 } 569 570 // safely limiting the kinds of caches this can produce 571 @SuppressWarnings("unchecked") 572 CacheBuilder<K1, V1> me = (CacheBuilder<K1, V1>) this; 573 me.weigher = checkNotNull(weigher); 574 return me; 575 } 576 577 long getMaximumWeight() { 578 if (expireAfterWriteNanos == 0 || expireAfterAccessNanos == 0) { 579 return 0; 580 } 581 return (weigher == null) ? maximumSize : maximumWeight; 582 } 583 584 // Make a safe contravariant cast now so we don't have to do it over and over. 585 @SuppressWarnings("unchecked") 586 <K1 extends K, V1 extends V> Weigher<K1, V1> getWeigher() { 587 return (Weigher<K1, V1>) MoreObjects.firstNonNull(weigher, OneWeigher.INSTANCE); 588 } 589 590 /** 591 * Specifies that each key (not value) stored in the cache should be wrapped in a {@link 592 * WeakReference} (by default, strong references are used). 593 * 594 * <p><b>Warning:</b> when this method is used, the resulting cache will use identity ({@code ==}) 595 * comparison to determine equality of keys. Its {@link Cache#asMap} view will therefore 596 * technically violate the {@link Map} specification (in the same way that {@link IdentityHashMap} 597 * does). 598 * 599 * <p>Entries with keys that have been garbage collected may be counted in {@link Cache#size}, but 600 * will never be visible to read or write operations; such entries are cleaned up as part of the 601 * routine maintenance described in the class javadoc. 602 * 603 * @return this {@code CacheBuilder} instance (for chaining) 604 * @throws IllegalStateException if the key strength was already set 605 */ 606 @GwtIncompatible // java.lang.ref.WeakReference 607 public CacheBuilder<K, V> weakKeys() { 608 return setKeyStrength(Strength.WEAK); 609 } 610 611 CacheBuilder<K, V> setKeyStrength(Strength strength) { 612 checkState(keyStrength == null, "Key strength was already set to %s", keyStrength); 613 keyStrength = checkNotNull(strength); 614 return this; 615 } 616 617 Strength getKeyStrength() { 618 return MoreObjects.firstNonNull(keyStrength, Strength.STRONG); 619 } 620 621 /** 622 * Specifies that each value (not key) stored in the cache should be wrapped in a {@link 623 * WeakReference} (by default, strong references are used). 624 * 625 * <p>Weak values will be garbage collected once they are weakly reachable. This makes them a poor 626 * candidate for caching; consider {@link #softValues} instead. 627 * 628 * <p><b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==}) 629 * comparison to determine equality of values. 630 * 631 * <p>Entries with values that have been garbage collected may be counted in {@link Cache#size}, 632 * but will never be visible to read or write operations; such entries are cleaned up as part of 633 * the routine maintenance described in the class javadoc. 634 * 635 * @return this {@code CacheBuilder} instance (for chaining) 636 * @throws IllegalStateException if the value strength was already set 637 */ 638 @GwtIncompatible // java.lang.ref.WeakReference 639 public CacheBuilder<K, V> weakValues() { 640 return setValueStrength(Strength.WEAK); 641 } 642 643 /** 644 * Specifies that each value (not key) stored in the cache should be wrapped in a {@link 645 * SoftReference} (by default, strong references are used). Softly-referenced objects will be 646 * garbage-collected in a <i>globally</i> least-recently-used manner, in response to memory 647 * demand. 648 * 649 * <p><b>Warning:</b> in most circumstances it is better to set a per-cache {@linkplain 650 * #maximumSize(long) maximum size} instead of using soft references. You should only use this 651 * method if you are well familiar with the practical consequences of soft references. 652 * 653 * <p><b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==}) 654 * comparison to determine equality of values. 655 * 656 * <p>Entries with values that have been garbage collected may be counted in {@link Cache#size}, 657 * but will never be visible to read or write operations; such entries are cleaned up as part of 658 * the routine maintenance described in the class javadoc. 659 * 660 * @return this {@code CacheBuilder} instance (for chaining) 661 * @throws IllegalStateException if the value strength was already set 662 */ 663 @GwtIncompatible // java.lang.ref.SoftReference 664 public CacheBuilder<K, V> softValues() { 665 return setValueStrength(Strength.SOFT); 666 } 667 668 CacheBuilder<K, V> setValueStrength(Strength strength) { 669 checkState(valueStrength == null, "Value strength was already set to %s", valueStrength); 670 valueStrength = checkNotNull(strength); 671 return this; 672 } 673 674 Strength getValueStrength() { 675 return MoreObjects.firstNonNull(valueStrength, Strength.STRONG); 676 } 677 678 /** 679 * Specifies that each entry should be automatically removed from the cache once a fixed duration 680 * has elapsed after the entry's creation, or the most recent replacement of its value. 681 * 682 * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long) 683 * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be 684 * useful in testing, or to disable caching temporarily without a code change. 685 * 686 * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or 687 * write operations. Expired entries are cleaned up as part of the routine maintenance described 688 * in the class javadoc. 689 * 690 * @param duration the length of time after an entry is created that it should be automatically 691 * removed 692 * @return this {@code CacheBuilder} instance (for chaining) 693 * @throws IllegalArgumentException if {@code duration} is negative 694 * @throws IllegalStateException if {@link #expireAfterWrite} was already set 695 * @throws ArithmeticException for durations greater than +/- approximately 292 years 696 * @since 25.0 697 */ 698 @J2ObjCIncompatible 699 @GwtIncompatible // java.time.Duration 700 @SuppressWarnings("GoodTime") // java.time.Duration decomposition 701 public CacheBuilder<K, V> expireAfterWrite(java.time.Duration duration) { 702 return expireAfterWrite(toNanosSaturated(duration), TimeUnit.NANOSECONDS); 703 } 704 705 /** 706 * Specifies that each entry should be automatically removed from the cache once a fixed duration 707 * has elapsed after the entry's creation, or the most recent replacement of its value. 708 * 709 * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long) 710 * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be 711 * useful in testing, or to disable caching temporarily without a code change. 712 * 713 * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or 714 * write operations. Expired entries are cleaned up as part of the routine maintenance described 715 * in the class javadoc. 716 * 717 * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred 718 * when feasible), use {@link #expireAfterWrite(Duration)} instead. 719 * 720 * @param duration the length of time after an entry is created that it should be automatically 721 * removed 722 * @param unit the unit that {@code duration} is expressed in 723 * @return this {@code CacheBuilder} instance (for chaining) 724 * @throws IllegalArgumentException if {@code duration} is negative 725 * @throws IllegalStateException if {@link #expireAfterWrite} was already set 726 */ 727 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 728 public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) { 729 checkState( 730 expireAfterWriteNanos == UNSET_INT, 731 "expireAfterWrite was already set to %s ns", 732 expireAfterWriteNanos); 733 checkArgument(duration >= 0, "duration cannot be negative: %s %s", duration, unit); 734 this.expireAfterWriteNanos = unit.toNanos(duration); 735 return this; 736 } 737 738 @SuppressWarnings("GoodTime") // nanos internally, should be Duration 739 long getExpireAfterWriteNanos() { 740 return (expireAfterWriteNanos == UNSET_INT) ? DEFAULT_EXPIRATION_NANOS : expireAfterWriteNanos; 741 } 742 743 /** 744 * Specifies that each entry should be automatically removed from the cache once a fixed duration 745 * has elapsed after the entry's creation, the most recent replacement of its value, or its last 746 * access. Access time is reset by all cache read and write operations (including {@code 747 * Cache.asMap().get(Object)} and {@code Cache.asMap().put(K, V)}), but not by {@code 748 * containsKey(Object)}, nor by operations on the collection-views of {@link Cache#asMap}}. So, 749 * for example, iterating through {@code Cache.asMap().entrySet()} does not reset access time for 750 * the entries you retrieve. 751 * 752 * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long) 753 * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be 754 * useful in testing, or to disable caching temporarily without a code change. 755 * 756 * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or 757 * write operations. Expired entries are cleaned up as part of the routine maintenance described 758 * in the class javadoc. 759 * 760 * @param duration the length of time after an entry is last accessed that it should be 761 * automatically removed 762 * @return this {@code CacheBuilder} instance (for chaining) 763 * @throws IllegalArgumentException if {@code duration} is negative 764 * @throws IllegalStateException if {@link #expireAfterAccess} was already set 765 * @throws ArithmeticException for durations greater than +/- approximately 292 years 766 * @since 25.0 767 */ 768 @J2ObjCIncompatible 769 @GwtIncompatible // java.time.Duration 770 @SuppressWarnings("GoodTime") // java.time.Duration decomposition 771 public CacheBuilder<K, V> expireAfterAccess(java.time.Duration duration) { 772 return expireAfterAccess(toNanosSaturated(duration), TimeUnit.NANOSECONDS); 773 } 774 775 /** 776 * Specifies that each entry should be automatically removed from the cache once a fixed duration 777 * has elapsed after the entry's creation, the most recent replacement of its value, or its last 778 * access. Access time is reset by all cache read and write operations (including {@code 779 * Cache.asMap().get(Object)} and {@code Cache.asMap().put(K, V)}), but not by {@code 780 * containsKey(Object)}, nor by operations on the collection-views of {@link Cache#asMap}. So, for 781 * example, iterating through {@code Cache.asMap().entrySet()} does not reset access time for the 782 * entries you retrieve. 783 * 784 * <p>When {@code duration} is zero, this method hands off to {@link #maximumSize(long) 785 * maximumSize}{@code (0)}, ignoring any otherwise-specified maximum size or weight. This can be 786 * useful in testing, or to disable caching temporarily without a code change. 787 * 788 * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or 789 * write operations. Expired entries are cleaned up as part of the routine maintenance described 790 * in the class javadoc. 791 * 792 * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred 793 * when feasible), use {@link #expireAfterAccess(Duration)} instead. 794 * 795 * @param duration the length of time after an entry is last accessed that it should be 796 * automatically removed 797 * @param unit the unit that {@code duration} is expressed in 798 * @return this {@code CacheBuilder} instance (for chaining) 799 * @throws IllegalArgumentException if {@code duration} is negative 800 * @throws IllegalStateException if {@link #expireAfterAccess} was already set 801 */ 802 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 803 public CacheBuilder<K, V> expireAfterAccess(long duration, TimeUnit unit) { 804 checkState( 805 expireAfterAccessNanos == UNSET_INT, 806 "expireAfterAccess was already set to %s ns", 807 expireAfterAccessNanos); 808 checkArgument(duration >= 0, "duration cannot be negative: %s %s", duration, unit); 809 this.expireAfterAccessNanos = unit.toNanos(duration); 810 return this; 811 } 812 813 @SuppressWarnings("GoodTime") // nanos internally, should be Duration 814 long getExpireAfterAccessNanos() { 815 return (expireAfterAccessNanos == UNSET_INT) 816 ? DEFAULT_EXPIRATION_NANOS 817 : expireAfterAccessNanos; 818 } 819 820 /** 821 * Specifies that active entries are eligible for automatic refresh once a fixed duration has 822 * elapsed after the entry's creation, or the most recent replacement of its value. The semantics 823 * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link 824 * CacheLoader#reload}. 825 * 826 * <p>As the default implementation of {@link CacheLoader#reload} is synchronous, it is 827 * recommended that users of this method override {@link CacheLoader#reload} with an asynchronous 828 * implementation; otherwise refreshes will be performed during unrelated cache read and write 829 * operations. 830 * 831 * <p>Currently automatic refreshes are performed when the first stale request for an entry 832 * occurs. The request triggering refresh will make a synchronous call to {@link 833 * CacheLoader#reload} 834 * to obtain a future of the new value. If the returned future is already complete, it is returned 835 * immediately. Otherwise, the old value is returned. 836 * 837 * <p><b>Note:</b> <i>all exceptions thrown during refresh will be logged and then swallowed</i>. 838 * 839 * @param duration the length of time after an entry is created that it should be considered 840 * stale, and thus eligible for refresh 841 * @return this {@code CacheBuilder} instance (for chaining) 842 * @throws IllegalArgumentException if {@code duration} is negative 843 * @throws IllegalStateException if {@link #refreshAfterWrite} was already set 844 * @throws ArithmeticException for durations greater than +/- approximately 292 years 845 * @since 25.0 846 */ 847 @J2ObjCIncompatible 848 @GwtIncompatible // java.time.Duration 849 @SuppressWarnings("GoodTime") // java.time.Duration decomposition 850 public CacheBuilder<K, V> refreshAfterWrite(java.time.Duration duration) { 851 return refreshAfterWrite(toNanosSaturated(duration), TimeUnit.NANOSECONDS); 852 } 853 854 /** 855 * Specifies that active entries are eligible for automatic refresh once a fixed duration has 856 * elapsed after the entry's creation, or the most recent replacement of its value. The semantics 857 * of refreshes are specified in {@link LoadingCache#refresh}, and are performed by calling {@link 858 * CacheLoader#reload}. 859 * 860 * <p>As the default implementation of {@link CacheLoader#reload} is synchronous, it is 861 * recommended that users of this method override {@link CacheLoader#reload} with an asynchronous 862 * implementation; otherwise refreshes will be performed during unrelated cache read and write 863 * operations. 864 * 865 * <p>Currently automatic refreshes are performed when the first stale request for an entry 866 * occurs. The request triggering refresh will make a synchronous call to {@link 867 * CacheLoader#reload} 868 * and immediately return the new value if the returned future is complete, and the old value 869 * otherwise. 870 * 871 * <p><b>Note:</b> <i>all exceptions thrown during refresh will be logged and then swallowed</i>. 872 * 873 * <p>If you can represent the duration as a {@link java.time.Duration} (which should be preferred 874 * when feasible), use {@link #refreshAfterWrite(Duration)} instead. 875 * 876 * @param duration the length of time after an entry is created that it should be considered 877 * stale, and thus eligible for refresh 878 * @param unit the unit that {@code duration} is expressed in 879 * @return this {@code CacheBuilder} instance (for chaining) 880 * @throws IllegalArgumentException if {@code duration} is negative 881 * @throws IllegalStateException if {@link #refreshAfterWrite} was already set 882 * @since 11.0 883 */ 884 @GwtIncompatible // To be supported (synchronously). 885 @SuppressWarnings("GoodTime") // should accept a java.time.Duration 886 public CacheBuilder<K, V> refreshAfterWrite(long duration, TimeUnit unit) { 887 checkNotNull(unit); 888 checkState(refreshNanos == UNSET_INT, "refresh was already set to %s ns", refreshNanos); 889 checkArgument(duration > 0, "duration must be positive: %s %s", duration, unit); 890 this.refreshNanos = unit.toNanos(duration); 891 return this; 892 } 893 894 @SuppressWarnings("GoodTime") // nanos internally, should be Duration 895 long getRefreshNanos() { 896 return (refreshNanos == UNSET_INT) ? DEFAULT_REFRESH_NANOS : refreshNanos; 897 } 898 899 /** 900 * Specifies a nanosecond-precision time source for this cache. By default, {@link 901 * System#nanoTime} is used. 902 * 903 * <p>The primary intent of this method is to facilitate testing of caches with a fake or mock 904 * time source. 905 * 906 * @return this {@code CacheBuilder} instance (for chaining) 907 * @throws IllegalStateException if a ticker was already set 908 */ 909 public CacheBuilder<K, V> ticker(Ticker ticker) { 910 checkState(this.ticker == null); 911 this.ticker = checkNotNull(ticker); 912 return this; 913 } 914 915 Ticker getTicker(boolean recordsTime) { 916 if (ticker != null) { 917 return ticker; 918 } 919 return recordsTime ? Ticker.systemTicker() : NULL_TICKER; 920 } 921 922 /** 923 * Specifies a listener instance that caches should notify each time an entry is removed for any 924 * {@linkplain RemovalCause reason}. Each cache created by this builder will invoke this listener 925 * as part of the routine maintenance described in the class documentation above. 926 * 927 * <p><b>Warning:</b> after invoking this method, do not continue to use <i>this</i> cache builder 928 * reference; instead use the reference this method <i>returns</i>. At runtime, these point to the 929 * same instance, but only the returned reference has the correct generic type information so as 930 * to ensure type safety. For best results, use the standard method-chaining idiom illustrated in 931 * the class documentation above, configuring a builder and building your cache in a single 932 * statement. Failure to heed this advice can result in a {@link ClassCastException} being thrown 933 * by a cache operation at some <i>undefined</i> point in the future. 934 * 935 * <p><b>Warning:</b> any exception thrown by {@code listener} will <i>not</i> be propagated to 936 * the {@code Cache} user, only logged via a {@link Logger}. 937 * 938 * @return the cache builder reference that should be used instead of {@code this} for any 939 * remaining configuration and cache building 940 * @return this {@code CacheBuilder} instance (for chaining) 941 * @throws IllegalStateException if a removal listener was already set 942 */ 943 @CheckReturnValue 944 public <K1 extends K, V1 extends V> CacheBuilder<K1, V1> removalListener( 945 RemovalListener<? super K1, ? super V1> listener) { 946 checkState(this.removalListener == null); 947 948 // safely limiting the kinds of caches this can produce 949 @SuppressWarnings("unchecked") 950 CacheBuilder<K1, V1> me = (CacheBuilder<K1, V1>) this; 951 me.removalListener = checkNotNull(listener); 952 return me; 953 } 954 955 // Make a safe contravariant cast now so we don't have to do it over and over. 956 @SuppressWarnings("unchecked") 957 <K1 extends K, V1 extends V> RemovalListener<K1, V1> getRemovalListener() { 958 return (RemovalListener<K1, V1>) 959 MoreObjects.firstNonNull(removalListener, NullListener.INSTANCE); 960 } 961 962 /** 963 * Enable the accumulation of {@link CacheStats} during the operation of the cache. Without this 964 * {@link Cache#stats} will return zero for all statistics. Note that recording stats requires 965 * bookkeeping to be performed with each operation, and thus imposes a performance penalty on 966 * cache operation. 967 * 968 * @return this {@code CacheBuilder} instance (for chaining) 969 * @since 12.0 (previously, stats collection was automatic) 970 */ 971 public CacheBuilder<K, V> recordStats() { 972 statsCounterSupplier = CACHE_STATS_COUNTER; 973 return this; 974 } 975 976 boolean isRecordingStats() { 977 return statsCounterSupplier == CACHE_STATS_COUNTER; 978 } 979 980 Supplier<? extends StatsCounter> getStatsCounterSupplier() { 981 return statsCounterSupplier; 982 } 983 984 /** 985 * Builds a cache, which either returns an already-loaded value for a given key or atomically 986 * computes or retrieves it using the supplied {@code CacheLoader}. If another thread is currently 987 * loading the value for this key, simply waits for that thread to finish and returns its loaded 988 * value. Note that multiple threads can concurrently load values for distinct keys. 989 * 990 * <p>This method does not alter the state of this {@code CacheBuilder} instance, so it can be 991 * invoked again to create multiple independent caches. 992 * 993 * @param loader the cache loader used to obtain new values 994 * @return a cache having the requested features 995 */ 996 @CheckReturnValue 997 public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build( 998 CacheLoader<? super K1, V1> loader) { 999 checkWeightWithWeigher(); 1000 return new LocalCache.LocalLoadingCache<>(this, loader); 1001 } 1002 1003 /** 1004 * Builds a cache which does not automatically load values when keys are requested. 1005 * 1006 * <p>Consider {@link #build(CacheLoader)} instead, if it is feasible to implement a {@code 1007 * CacheLoader}. 1008 * 1009 * <p>This method does not alter the state of this {@code CacheBuilder} instance, so it can be 1010 * invoked again to create multiple independent caches. 1011 * 1012 * @return a cache having the requested features 1013 * @since 11.0 1014 */ 1015 @CheckReturnValue 1016 public <K1 extends K, V1 extends V> Cache<K1, V1> build() { 1017 checkWeightWithWeigher(); 1018 checkNonLoadingCache(); 1019 return new LocalCache.LocalManualCache<>(this); 1020 } 1021 1022 private void checkNonLoadingCache() { 1023 checkState(refreshNanos == UNSET_INT, "refreshAfterWrite requires a LoadingCache"); 1024 } 1025 1026 private void checkWeightWithWeigher() { 1027 if (weigher == null) { 1028 checkState(maximumWeight == UNSET_INT, "maximumWeight requires weigher"); 1029 } else { 1030 if (strictParsing) { 1031 checkState(maximumWeight != UNSET_INT, "weigher requires maximumWeight"); 1032 } else { 1033 if (maximumWeight == UNSET_INT) { 1034 logger.log(Level.WARNING, "ignoring weigher specified without maximumWeight"); 1035 } 1036 } 1037 } 1038 } 1039 1040 /** 1041 * Returns a string representation for this CacheBuilder instance. The exact form of the returned 1042 * string is not specified. 1043 */ 1044 @Override 1045 public String toString() { 1046 MoreObjects.ToStringHelper s = MoreObjects.toStringHelper(this); 1047 if (initialCapacity != UNSET_INT) { 1048 s.add("initialCapacity", initialCapacity); 1049 } 1050 if (concurrencyLevel != UNSET_INT) { 1051 s.add("concurrencyLevel", concurrencyLevel); 1052 } 1053 if (maximumSize != UNSET_INT) { 1054 s.add("maximumSize", maximumSize); 1055 } 1056 if (maximumWeight != UNSET_INT) { 1057 s.add("maximumWeight", maximumWeight); 1058 } 1059 if (expireAfterWriteNanos != UNSET_INT) { 1060 s.add("expireAfterWrite", expireAfterWriteNanos + "ns"); 1061 } 1062 if (expireAfterAccessNanos != UNSET_INT) { 1063 s.add("expireAfterAccess", expireAfterAccessNanos + "ns"); 1064 } 1065 if (keyStrength != null) { 1066 s.add("keyStrength", Ascii.toLowerCase(keyStrength.toString())); 1067 } 1068 if (valueStrength != null) { 1069 s.add("valueStrength", Ascii.toLowerCase(valueStrength.toString())); 1070 } 1071 if (keyEquivalence != null) { 1072 s.addValue("keyEquivalence"); 1073 } 1074 if (valueEquivalence != null) { 1075 s.addValue("valueEquivalence"); 1076 } 1077 if (removalListener != null) { 1078 s.addValue("removalListener"); 1079 } 1080 return s.toString(); 1081 } 1082 1083 /** 1084 * Returns the number of nanoseconds of the given duration without throwing or overflowing. 1085 * 1086 * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either 1087 * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing 1088 * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair. 1089 */ 1090 @GwtIncompatible // java.time.Duration 1091 @SuppressWarnings("GoodTime") // duration decomposition 1092 private static long toNanosSaturated(java.time.Duration duration) { 1093 // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for 1094 // durations longer than approximately +/- 292 years). 1095 try { 1096 return duration.toNanos(); 1097 } catch (ArithmeticException tooBig) { 1098 return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE; 1099 } 1100 } 1101}