Method refresh

output/java_guava/1.4.13/LocalCache.java:2457–3485

Refreshes the value associated with key, unless another thread is already doing so. Returns the newly refreshed value associated with key if it was refreshed inline, or null if another thread is performing the refresh or if an error occurs during refresh.

(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime)

     */

    @Nullable
    V refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {
                   final LoadingValueReference<K, V> loadingValueReference = insertLoadingValueReference(key, hash, checkTime);
                   if (loadingValueReference == null) {
        return null;
                   }
                   ListenableFuture<V> result = loadAsync(key, hash, loadingValueReference, loader);
                   if (result.isDone()) {
        try {
                       return Uninterruptibles.getUninterruptibly(result);
        } catch (Throwable t) {
          // don't let refresh exceptions propagate; error was already logged}
                   }
                   return null;
    }

    /**
     * Returns a newly inserted {@code LoadingValueReference}, or null if the live value reference
     * is already loading.
     */

    @Nullable
    LoadingValueReference<K, V> insertLoadingValueReference(final K key, final int hash, boolean checkTime) {
                   ReferenceEntry<K, V> e = null;
                   lock();
                   try {
        long now = map.ticker.read();
        preWriteCleanup(now);
        AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
        int index = hash & (table.length() - 1);
        ReferenceEntry<K, V> first = table.get(index);

        // Look for an existing entry.
        for (e = first; e != null; e = e.getNext()) {
                       K entryKey = e.getKey();
                       if (e.getHash() == hash && entryKey != null
                           && map.keyEquivalence.equivalent(key, entryKey)) {
            // We found an existing entry.
                           ValueReference<K, V> valueReference = e.getValueReference();
                           if (valueReference.isLoading()
                               || (checkTime && (now - e.getWriteTime() < map.refreshNanos))) {
              // refresh is a no-op if loading is pending
              // if checkTime, we want to check *after* acquiring the lock if refresh still needs
              // to be scheduled
                                                        return null;
                           }

            // continue returning old value while loading
                           ++modCount;
                           LoadingValueReference<K, V> loadingValueReference = new LoadingValueReference<K, V>(valueReference);
                           e.setValueReference(loadingValueReference);
                           return loadingValueReference;
                       }
        }
        ++modCount;
        LoadingValueReference<K, V> loadingValueReference = new LoadingValueReference<K, V>();
        e = newEntry(key, hash, first);
        e.setValueReference(loadingValueReference);