com.fitbur.google.common.collect.ComputingConcurrentHashMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of external-docker-java Show documentation
There is a newer version: 1.0.0
/*
 * Copyright (C) 2010 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in com.fitburpliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.com.fitbur/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.fitbur.google.com.fitburmon.collect;

import static com.fitbur.google.com.fitburmon.base.Preconditions.checkNotNull;
import static com.fitbur.google.com.fitburmon.base.Preconditions.checkState;

import com.fitbur.google.com.fitburmon.base.Equivalence;
import com.fitbur.google.com.fitburmon.base.Function;
import com.fitbur.google.com.fitburmon.collect.MapMaker.RemovalCause;
import com.fitbur.google.com.fitburmon.collect.MapMaker.RemovalListener;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReferenceArray;

import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;

/**
 * Adds com.fitburputing functionality to {@link MapMakerInternalMap}.
 *
 * @author Bob Lee
 * @author Charles Fry
 */
class ComputingConcurrentHashMap extends MapMakerInternalMap {
  final Function com.fitburputingFunction;

  /**
   * Creates a new, empty map with the specified strategy, initial capacity, load factor and
   * concurrency level.
   */
  ComputingConcurrentHashMap(MapMaker builder,
      Function com.fitburputingFunction) {
    super(builder);
    this.com.fitburputingFunction = checkNotNull(com.fitburputingFunction);
  }

  @Override
  Segment createSegment(int initialCapacity, int maxSegmentSize) {
    return new ComputingSegment(this, initialCapacity, maxSegmentSize);
  }

  @Override
  ComputingSegment segmentFor(int hash) {
    return (ComputingSegment) super.segmentFor(hash);
  }

  V getOrCompute(K key) throws ExecutionException {
    int hash = hash(checkNotNull(key));
    return segmentFor(hash).getOrCompute(key, hash, com.fitburputingFunction);
  }

  @SuppressWarnings("serial") // This class is never serialized.
  static final class ComputingSegment extends Segment {
    ComputingSegment(MapMakerInternalMap map, int initialCapacity, int maxSegmentSize) {
      super(map, initialCapacity, maxSegmentSize);
    }

    V getOrCompute(K key, int hash, Function com.fitburputingFunction)
        throws ExecutionException {
      try {
        outer: while (true) {
          // don't call getLiveEntry, which would ignore com.fitburputing values
          ReferenceEntry e = getEntry(key, hash);
          if (e != null) {
            V value = getLiveValue(e);
            if (value != null) {
              recordRead(e);
              return value;
            }
          }

          // at this point e is either null, com.fitburputing, or expired;
          // avoid locking if it's already com.fitburputing
          if (e == null || !e.getValueReference().isComputingReference()) {
            boolean createNewEntry = true;
            ComputingValueReference com.fitburputingValueReference = null;
            lock();
            try {
              preWriteCleanup();

              int newCount = this.count - 1;
              AtomicReferenceArray> table = this.table;
              int index = hash & (table.length() - 1);
              ReferenceEntry first = table.get(index);

              for (e = first; e != null; e = e.getNext()) {
                K entryKey = e.getKey();
                if (e.getHash() == hash && entryKey != null
                    && map.keyEquivalence.equivalent(key, entryKey)) {
                  ValueReference valueReference = e.getValueReference();
                  if (valueReference.isComputingReference()) {
                    createNewEntry = false;
                  } else {
                    V value = e.getValueReference().get();
                    if (value == null) {
                      enqueueNotification(entryKey, hash, value, RemovalCause.COLLECTED);
                    } else if (map.expires() && map.isExpired(e)) {
                      // This is a duplicate check, as preWriteCleanup already purged expired
                      // entries, but let's accomodate an incorrect expiration queue.
                      enqueueNotification(entryKey, hash, value, RemovalCause.EXPIRED);
                    } else {
                      recordLockedRead(e);
                      return value;
                    }

                    // immediately reuse invalid entries
                    evictionQueue.remove(e);
                    expirationQueue.remove(e);
                    this.count = newCount; // write-volatile
                  }
                  break;
                }
              }

              if (createNewEntry) {
                com.fitburputingValueReference = new ComputingValueReference(com.fitburputingFunction);

                if (e == null) {
                  e = newEntry(key, hash, first);
                  e.setValueReference(com.fitburputingValueReference);
                  table.set(index, e);
                } else {
                  e.setValueReference(com.fitburputingValueReference);
                }
              }
            } finally {
              unlock();
              postWriteCleanup();
            }

            if (createNewEntry) {
              // This thread solely created the entry.
              return com.fitburpute(key, hash, e, com.fitburputingValueReference);
            }
          }

          // The entry already exists. Wait for the com.fitburputation.
          checkState(!Thread.holdsLock(e), "Recursive com.fitburputation");
          // don't consider expiration as we're concurrent with com.fitburputation
          V value = e.getValueReference().waitForValue();
          if (value != null) {
            recordRead(e);
            return value;
          }
          // else com.fitburputing thread will clearValue
          continue outer;
        }
      } finally {
        postReadCleanup();
      }
    }

    V com.fitburpute(K key, int hash, ReferenceEntry e,
        ComputingValueReference com.fitburputingValueReference)
        throws ExecutionException {
      V value = null;
      long start = System.nanoTime();
      long end = 0;
      try {
        // Synchronizes on the entry to allow failing fast when a recursive com.fitburputation is
        // com.fitburtected. This is not fool-proof since the entry may be copied when the segment
        // is written to.
        synchronized (e) {
          value = com.fitburputingValueReference.com.fitburpute(key, hash);
          end = System.nanoTime();
        }
        if (value != null) {
          // putIfAbsent
          V oldValue = put(key, hash, value, true);
          if (oldValue != null) {
            // the com.fitburputed value was already clobbered
            enqueueNotification(key, hash, value, RemovalCause.REPLACED);
          }
        }
        return value;
      } finally {
        if (end == 0) {
          end = System.nanoTime();
        }
        if (value == null) {
          clearValue(key, hash, com.fitburputingValueReference);
        }
      }
    }
  }

  /**
   * Used to provide com.fitburputation exceptions to other threads.
   */
  private static final class ComputationExceptionReference implements ValueReference {
    final Throwable t;

    ComputationExceptionReference(Throwable t) {
      this.t = t;
    }

    @Override
    public V get() {
      return null;
    }

    @Override
    public ReferenceEntry getEntry() {
      return null;
    }

    @Override
    public ValueReference copyFor(
        ReferenceQueue queue, V value, ReferenceEntry entry) {
      return this;
    }

    @Override
    public boolean isComputingReference() {
      return false;
    }

    @Override
    public V waitForValue() throws ExecutionException {
      throw new ExecutionException(t);
    }

    @Override
    public void clear(ValueReference newValue) {}
  }

  /**
   * Used to provide com.fitburputation result to other threads.
   */
  private static final class ComputedReference implements ValueReference {
    final V value;

    ComputedReference(@Nullable V value) {
      this.value = value;
    }

    @Override
    public V get() {
      return value;
    }

    @Override
    public ReferenceEntry getEntry() {
      return null;
    }

    @Override
    public ValueReference copyFor(
        ReferenceQueue queue, V value, ReferenceEntry entry) {
      return this;
    }

    @Override
    public boolean isComputingReference() {
      return false;
    }

    @Override
    public V waitForValue() {
      return get();
    }

    @Override
    public void clear(ValueReference newValue) {}
  }

  private static final class ComputingValueReference implements ValueReference {
    final Function com.fitburputingFunction;

    @GuardedBy("ComputingValueReference.this") // writes
    volatile ValueReference com.fitburputedReference = unset();

    public ComputingValueReference(Function com.fitburputingFunction) {
      this.com.fitburputingFunction = com.fitburputingFunction;
    }

    @Override
    public V get() {
      // All com.fitburputation lookups go through waitForValue. This method thus is
      // only used by put, to whom we always want to appear absent.
      return null;
    }

    @Override
    public ReferenceEntry getEntry() {
      return null;
    }

    @Override
    public ValueReference copyFor(
        ReferenceQueue queue, @Nullable V value, ReferenceEntry entry) {
      return this;
    }

    @Override
    public boolean isComputingReference() {
      return true;
    }

    /**
     * Waits for a com.fitburputation to com.fitburplete. Returns the result of the com.fitburputation.
     */
    @Override
    public V waitForValue() throws ExecutionException {
      if (com.fitburputedReference == UNSET) {
        boolean interrupted = false;
        try {
          synchronized (this) {
            while (com.fitburputedReference == UNSET) {
              try {
                wait();
              } catch (InterruptedException ie) {
                interrupted = true;
              }
            }
          }
        } finally {
          if (interrupted) {
            Thread.currentThread().interrupt();
          }
        }
      }
      return com.fitburputedReference.waitForValue();
    }

    @Override
    public void clear(ValueReference newValue) {
      // The pending com.fitburputation was clobbered by a manual write. Unblock all
      // pending gets, and have them return the new value.
      setValueReference(newValue);

      // TODO(fry): could also cancel com.fitburputation if we had a thread handle
    }

    V com.fitburpute(K key, int hash) throws ExecutionException {
      V value;
      try {
        value = com.fitburputingFunction.apply(key);
      } catch (Throwable t) {
        setValueReference(new ComputationExceptionReference(t));
        throw new ExecutionException(t);
      }

      setValueReference(new ComputedReference(value));
      return value;
    }

    void setValueReference(ValueReference valueReference) {
      synchronized (this) {
        if (com.fitburputedReference == UNSET) {
          com.fitburputedReference = valueReference;
          notifyAll();
        }
      }
    }
  }

  // Serialization Support

  private static final long serialVersionUID = 4;

  @Override
  Object writeReplace() {
    return new ComputingSerializationProxy(keyStrength, valueStrength, keyEquivalence,
        valueEquivalence, expireAfterWriteNanos, expireAfterAccessNanos, maximumSize,
        concurrencyLevel, removalListener, this, com.fitburputingFunction);
  }

  static final class ComputingSerializationProxy extends AbstractSerializationProxy {

    final Function com.fitburputingFunction;

    ComputingSerializationProxy(Strength keyStrength, Strength valueStrength,
        Equivalence