assertThat(cache.getIfPresent(10)).isEqualTo(50);
    assertThat(asMap.get(10)).isEqualTo(50);
    assertThat(cache.getIfPresent(2)).isNull();
    assertThat(asMap.get(2)).isNull();

    asMap.putIfAbsent(2, 20);
    asMap.putIfAbsent(10, 20);

    assertThat(cache.getIfPresent(2)).isEqualTo(20);
    assertThat(asMap.get(2)).isEqualTo(20);
    assertThat(cache.getIfPresent(10)).isEqualTo(50);

            E result = (E) canonical;
            return result;
          }
        }

        // didn't see it, trying to put it instead...
        Dummy sneaky = map.putIfAbsent(sample, Dummy.VALUE);
        if (sneaky == null) {
          return sample;
        } else {
          /* Someone beat us to it! Trying again...
           *

                        request.getGroupId(),
                        request.getArtifactId(),
                        result.getVersion(),
                        result.getRepository());

                cache.putIfAbsent(key, result);
            } else {
                logger.debug(
                        "Reusing cached resolved plugin version for {}:{} to {} from POM {}",
                        request.getGroupId(),

            if (!Modifier.isStatic(method.getModifiers()) && method.getParameterCount() == 1) {
                Type[] paramTypes = method.getGenericParameterTypes();
                methodMap.putIfAbsent(method.getName(), new MethodInfo(method, paramTypes[0]));
            }
        }

        return methodMap;
    }

    /**
     * Check if method is compatible with value type.
     */

      if (eventSubscribers == null) {
        CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<>();
        eventSubscribers =
            MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);
      }

      eventSubscribers.addAll(eventMethodsInListener);
    }
  }

  /** Unregisters all subscribers on the given listener object. */
  void unregister(Object listener) {

        QueueHolder queueHolder = sessionCache.get(sessionId);
        if (queueHolder == null) {
            queueHolder = new QueueHolder();
            final QueueHolder prevQueueHolder = sessionCache.putIfAbsent(sessionId, queueHolder);
            return prevQueueHolder == null ? queueHolder : prevQueueHolder;
        }
        return queueHolder;
    }

    /**

     * @see ConcurrentHashMap#putIfAbsent(Object, Object)
     */
    public static <K, V> V putIfAbsent(final ConcurrentMap<K, V> map, final K key, final V value) {
        final V exists = map.putIfAbsent(key, value);
        if (exists != null) {
            return exists;
        }
        return value;
    }

    while (itr.hasNext()) {
      Entry<K, V> entry = itr.next();
      K k = entry.getKey();
      V v = entry.getValue();
      K conflict = inverse.delegate.putIfAbsent(v, k);
      if (conflict != null) {
        broken = entry;
        // We're definitely going to throw, but we'll try to keep the BiMap in an internally
        // consistent state by removing the bad entry.

                        byte[] nonce = context.generateNonce();
                        String nonceStr = Arrays.toString(nonce);
                        if (allNonces.putIfAbsent(nonceStr, true) != null) {
                            collisions.incrementAndGet();
                        }
                    }
                } finally {
                    latch.countDown();

        alertListenerIfPresent(entry.getKey(), entry.getValue().getValue(), RemovalCause.EXPLICIT);
      }
    }
    cachingHashMap.clear();
  }

  @Override
  public V putIfAbsent(K key, V value) {
    V currentValue = get(key);
    if (currentValue != null) {
      return currentValue;
    }
    return put(key, value);
  }

  @CanIgnoreReturnValue
  @Override