Fix OOM issues by switching from SOFT to WEAK references

Analysis of the working PR #2506 revealed that the key difference is the use
of WEAK references instead of SOFT references for cache entries.

Root Cause:
- SOFT references are only cleared when JVM is close to OutOfMemoryError
- This causes excessive memory retention and can lead to OOM in large builds
- WEAK references are cleared much more aggressively when objects are no longer
  strongly referenced, preventing memory buildup

Changes:
- Switch from SoftReference to WeakReference for both keys and values
- Update documentation to reflect the change from soft to weak references
- This aligns with the working PR #2506 which uses Cache.ReferenceType.WEAK

Benefits:
- Prevents OOM issues in integration tests and large builds
- Maintains caching benefits while allowing more aggressive garbage collection
- Follows the proven approach from the comprehensive PR #2506

All 12 cache tests continue to pass with this change.

Author: gnodet

impl/maven-impl/src/main/java/org/apache/maven/impl/cache/Cache.java

@@ -24,8 +24,9 @@
  * A simple cache interface for storing key-value pairs with automatic cleanup
  * of garbage-collected entries.
  *
- * <p>This cache uses soft references to allow garbage collection under memory
- * pressure while providing memory benefits for typical usage patterns.
+ * <p>This cache uses weak references to allow garbage collection when objects
+ * are no longer strongly referenced, preventing memory leaks while providing
+ * caching benefits for typical usage patterns.
  *
  * @param <K> the type of keys maintained by this cache
  * @param <V> the type of cached values

impl/maven-impl/src/main/java/org/apache/maven/impl/cache/DefaultCache.java

@@ -20,7 +20,7 @@
 
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
-import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
@@ -29,12 +29,12 @@
 import java.util.function.Function;
 
 /**
- * Default implementation of Cache that uses soft references for both keys and values,
+ * Default implementation of Cache that uses weak references for both keys and values,
  * with identity-based key comparison for better performance.
  *
  * <p>This implementation is thread-safe and automatically cleans up garbage-collected
- * entries. It uses soft references to allow garbage collection under memory pressure
- * while providing memory benefits for typical usage patterns.
+ * entries. It uses weak references to allow garbage collection when objects are no longer
+ * strongly referenced, preventing memory leaks while providing caching benefits.
  *
  * @param <K> the type of keys maintained by this cache
  * @param <V> the type of cached values
@@ -190,9 +190,9 @@ private void expungeStaleEntries() {
     }
 
     /**
-     * Soft reference wrapper for keys that uses identity-based equality.
+     * Weak reference wrapper for keys that uses identity-based equality.
      */
-    private static class KeyReference<K> extends SoftReference<K> {
+    private static class KeyReference<K> extends WeakReference<K> {
         private final int hashCode;
 
         KeyReference(K key, ReferenceQueue<K> queue) {
@@ -221,9 +221,9 @@ public int hashCode() {
     }
 
     /**
-     * Soft reference wrapper for values with computation state tracking.
+     * Weak reference wrapper for values with computation state tracking.
      */
-    private static class ValueReference<V> extends SoftReference<V> {
+    private static class ValueReference<V> extends WeakReference<V> {
         private final boolean computing;
 
         ValueReference(V value, ReferenceQueue<V> queue) {