}

        // Calculate weight without using computeIfAbsent to avoid recursive update issues
        long weight = calculateWeight(project);

        // Use putIfAbsent to handle concurrent access safely
        Long previousWeight = projectWeights.putIfAbsent(project, weight);
        return previousWeight != null ? previousWeight : weight;
    }

    private Comparator<MavenProject> createComparator() {

   *
   * <p>Caches loaded by a {@link CacheLoader} will call {@link CacheLoader#load} to load new values
   * into the cache. Newly loaded values are added to the cache using {@code
   * Cache.asMap().putIfAbsent} after loading has completed; if another value was associated with
   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *

        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertThat(cache.asMap().putIfAbsent(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        Object newKey = new Object();
        assertThat(cache.asMap().putIfAbsent(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below

    @Override
    public void replaceAll(final BiFunction<? super K, ? super V, ? extends V> function) {
        parent.replaceAll(function);
    }

    @Override
    public V putIfAbsent(final K key, final V value) {
        return parent.putIfAbsent(key, value);
    }

    @Override
    public boolean remove(final Object key, final Object value) {
        if (parent.remove(key, value)) {
            return true;

        return node1;
    }

    private Map<String, MojoExecution> mergeMojos(Map<String, MojoExecution> l1, Map<String, MojoExecution> l2) {
        l2.forEach(l1::putIfAbsent);
        return l1;
    }

    // gather artifactIds which are not unique so that the respective thread names can be extended with the groupId
    public Set<String> duplicateIds() {

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            throw uoe();
        }

        @Override
        public V putIfAbsent(K key, V value) {
            throw uoe();
        }

        @Override
        public boolean remove(Object key, Object value) {
            throw uoe();
        }

        @Override

     * @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;
    }

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

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

      synchronized (mutex) {
        return delegate().put(key, value);
      }
    }

    @Override
    public @Nullable V putIfAbsent(K key, V value) {
      synchronized (mutex) {
        return delegate().putIfAbsent(key, value);
      }
    }

    @Override
    public boolean replace(K key, V oldValue, V newValue) {
      synchronized (mutex) {

    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.putIfAbsent(key, newValue);
      long after = map.get(key);
      assertEquals(before, result);
      assertEquals(before == 0 ? newValue : before, after);

      map.remove(key);
      before = map.get(key);
      result = map.putIfAbsent(key, newValue);
      after = map.get(key);
      assertEquals(0, before);