This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch maven-4.0.x
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/maven-4.0.x by this push:
     new f3176e62c2 Do not store the default current project in threads that 
only read it (#13794) (#13802)
f3176e62c2 is described below

commit f3176e62c2c0bf106dca1cfe67e3b01891b36836
Author: Guillaume Nodet <[email protected]>
AuthorDate: Tue Nov 3 21:35:06 2026 +0100

    Do not store the default current project in threads that only read it 
(#13794) (#13802)
    
    MavenSession kept the current project in a ThreadLocal created with
    ThreadLocal.withInitial(...), and clone() gave every clone a new one.
    With withInitial, a plain get() on a thread without a value stores the
    initial value in that thread's ThreadLocalMap. Every thread that only
    read getCurrentProject() therefore kept a strong reference to the
    default project, and clone() itself reads the current project of the
    original session. After the session is discarded, these stale entries
    keep the project, and through it the whole build, reachable as long as
    the thread lives, e.g. on ForkJoinPool.commonPool workers in mvnd.
    
    The default project is now kept in a field, and the ThreadLocal holds
    only explicitly set projects (null is stored as Optional.empty()).
    Reading the current project on a thread without a value returns the
    default without storing it. The behavior is unchanged.
    
    Co-Authored-By: Claude Code (Anthropic Claude Opus 5.5, claude-opus-5-5)
    
    Co-authored-by: Christian Munier <[email protected]>
---
 .../org/apache/maven/execution/MavenSession.java   | 24 ++++++++++++-----
 .../apache/maven/execution/MavenSessionTest.java   | 31 ++++++++++++++++++++++
 2 files changed, 48 insertions(+), 7 deletions(-)

diff --git 
a/impl/maven-core/src/main/java/org/apache/maven/execution/MavenSession.java 
b/impl/maven-core/src/main/java/org/apache/maven/execution/MavenSession.java
index b50b345bfd..9e7770377d 100644
--- a/impl/maven-core/src/main/java/org/apache/maven/execution/MavenSession.java
+++ b/impl/maven-core/src/main/java/org/apache/maven/execution/MavenSession.java
@@ -25,6 +25,7 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -62,7 +63,13 @@ public class MavenSession implements Cloneable {
 
     private final Properties executionProperties;
 
-    private ThreadLocal<MavenProject> currentProject = new ThreadLocal<>();
+    /**
+     * The current project set on a thread, {@link Optional#empty()} if it was 
set to {@code null}. Threads without a
+     * value use {@link #defaultProject}, so that reading the current project 
never stores a project in the thread.
+     */
+    private ThreadLocal<Optional<MavenProject>> currentProject = new 
ThreadLocal<>();
+
+    private MavenProject defaultProject;
 
     /**
      * These projects have already been topologically sorted in the {@link 
org.apache.maven.Maven} component before
@@ -97,10 +104,12 @@ public void setProjects(List<MavenProject> projects) {
                     .filter(project -> project.isExecutionRoot())
                     .findFirst()
                     .orElse(projects.get(0));
-            this.currentProject = ThreadLocal.withInitial(() -> 
topLevelProject);
+            this.currentProject = new ThreadLocal<>();
+            this.defaultProject = topLevelProject;
             this.topLevelProject = topLevelProject;
         } else {
             this.currentProject = new ThreadLocal<>();
+            this.defaultProject = null;
             this.topLevelProject = null;
         }
         this.projects = projects;
@@ -172,11 +181,12 @@ public MavenExecutionRequest getRequest() {
     }
 
     public void setCurrentProject(MavenProject currentProject) {
-        this.currentProject.set(currentProject);
+        this.currentProject.set(Optional.ofNullable(currentProject));
     }
 
     public MavenProject getCurrentProject() {
-        return currentProject.get();
+        Optional<MavenProject> project = currentProject.get();
+        return project != null ? project.orElse(null) : defaultProject;
     }
 
     public ProjectBuildingRequest getProjectBuildingRequest() {
@@ -237,9 +247,9 @@ public MavenSession clone() {
         try {
             MavenSession clone = (MavenSession) super.clone();
             // the default must become the current project of the thread that 
clones this
-            MavenProject current = getCurrentProject();
-            // we replace the thread local of the clone to prevent write 
through and enforce the new default value
-            clone.currentProject = ThreadLocal.withInitial(() -> current);
+            clone.defaultProject = getCurrentProject();
+            // we replace the thread local of the clone to prevent write 
through
+            clone.currentProject = new ThreadLocal<>();
             return clone;
         } catch (CloneNotSupportedException e) {
             throw new RuntimeException("Bug", e);
diff --git 
a/impl/maven-core/src/test/java/org/apache/maven/execution/MavenSessionTest.java
 
b/impl/maven-core/src/test/java/org/apache/maven/execution/MavenSessionTest.java
index 8732d8e193..bf6b199daf 100644
--- 
a/impl/maven-core/src/test/java/org/apache/maven/execution/MavenSessionTest.java
+++ 
b/impl/maven-core/src/test/java/org/apache/maven/execution/MavenSessionTest.java
@@ -18,9 +18,11 @@
  */
 package org.apache.maven.execution;
 
+import java.lang.ref.WeakReference;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
@@ -156,6 +158,35 @@ void testCloneKeepsRuntimeCurrentProject() throws 
Exception {
         assertSame(root, session.getCurrentProject());
     }
 
+    @Test
+    void testReadingCurrentProjectOnOtherThreadDoesNotRetainProject() throws 
Exception {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        try {
+            WeakReference<MavenProject> root = 
readCurrentProjectOnThread(executor);
+            for (int i = 0; i < 10 && root.get() != null; i++) {
+                System.gc();
+                Thread.sleep(10);
+            }
+            assertNull(root.get(), "the thread must not retain the project 
after the session is discarded");
+        } finally {
+            executor.shutdownNow();
+        }
+    }
+
+    private WeakReference<MavenProject> 
readCurrentProjectOnThread(ExecutorService executor) throws Exception {
+        MavenSession session = createSessionWithoutContainer();
+        MavenProject root = new MavenProject();
+        root.setExecutionRoot(true);
+        session.setProjects(List.of(root));
+        executor.submit(() -> {
+                    assertSame(root, session.getCurrentProject());
+                    MavenSession clone = session.clone();
+                    assertSame(root, clone.getCurrentProject());
+                })
+                .get(10, TimeUnit.SECONDS);
+        return new WeakReference<>(root);
+    }
+
     /**
      * Creates a MavenSession without a PlexusContainer (Maven 4 style).
      */

Reply via email to