code: public V get(K key) throws E {
          clean();
  
          ValueRef<K, V> valueRef = mValues.get(key);
          V value;
  
          if (valueRef == null || (value = valueRef.get()) == null) {
              try {
                  value = create(key);
              } catch (Exception e) {
                  // Workaround compiler bug.
                  org.cojen.util.ThrowUnchecked.fire(e);
                  return null;
              }
              valueRef = new ValueRef<K, V>(value, mValueRefQueue, key);
              while (true) {
                  ValueRef<K, V> existingRef = mValues.putIfAbsent(key, valueRef);
                  if (existingRef == null) {
                      // Newly created value is now the official value.
                      break;
                  }
                  V existing = existingRef.get();
                  if (existing != null) {
                      // Someone else just created value before us. Use that
                      // instead and chuck the new value object.
                      value = existing;
                      valueRef.clear();
                      break;
                  }
                  // Reference just got cleared. Try again. Explicitly remove it
                  // to prevent an infinite loop. Note that the two argument
                  // remove method is called to ensure that what is being removed
                  // is not a new value.
                  mValues.remove(((ValueRef<K, V>) existingRef).mKey, existingRef);
              }
          }
  
          return value;
      }
docs: Returns a value for the given key. Unused values are automatically
  cleared to free up memory, even if they are still held. Repeat calls are
  guaranteed to return the same value instance only if the value is
  strongly reachable. The following idiom should be used when using the
  pool for maintaining locks:
  
  <pre>
  // Store lock in local variable to be strongly reachable.
  Lock lock = lockPool.get(key);
  lock.lock();
  try {
  // access the resource protected by this lock
  ...
  } finally {
  lock.unlock();
  }
  </pre>