[MNG-8711] Fix concurrent cache access

(cherry picked from commit ce15193) with simple conflict resolving

Author: gnodet

maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java

@@ -123,26 +123,29 @@ public void resolveProjectDependencies(
                 }
             }
 
-            Set<Artifact> resolvedArtifacts;
             ProjectArtifactsCache.Key cacheKey = projectArtifactsCache.createKey(
                     project, scopesToCollect, scopesToResolve, aggregating, session.getRepositorySession());
             ProjectArtifactsCache.CacheRecord recordArtifacts;
             recordArtifacts = projectArtifactsCache.get(cacheKey);
 
-            if (recordArtifacts != null) {
-                resolvedArtifacts = recordArtifacts.getArtifacts();
-            } else {
-                try {
-                    resolvedArtifacts = getDependencies(
-                            project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);
-                    recordArtifacts = projectArtifactsCache.put(cacheKey, resolvedArtifacts);
-                } catch (LifecycleExecutionException e) {
-                    projectArtifactsCache.put(cacheKey, e);
-                    projectArtifactsCache.register(project, cacheKey, recordArtifacts);
-                    throw e;
+            if (recordArtifacts == null) {
+                synchronized (cacheKey) {
+                    recordArtifacts = projectArtifactsCache.get(cacheKey);
+                    if (recordArtifacts == null) {
+                        try {
+                            Set<Artifact> resolvedArtifacts = getDependencies(
+                                    project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);
+                            recordArtifacts = projectArtifactsCache.put(cacheKey, resolvedArtifacts);
+                        } catch (LifecycleExecutionException e) {
+                            projectArtifactsCache.put(cacheKey, e);
+                            projectArtifactsCache.register(project, cacheKey, recordArtifacts);
+                            throw e;
+                        }
+                    }
                 }
             }
             projectArtifactsCache.register(project, cacheKey, recordArtifacts);
+            Set<Artifact> resolvedArtifacts = recordArtifacts.getArtifacts();
 
             Map<Artifact, File> reactorProjects =
                     new HashMap<>(session.getProjects().size());

maven-core/src/main/java/org/apache/maven/plugin/DefaultPluginDescriptorCache.java

@@ -50,13 +50,14 @@
 public class DefaultPluginDescriptorCache implements PluginDescriptorCache {
 
     private Map<Key, PluginDescriptor> descriptors = new ConcurrentHashMap<>(128);
+    private Map<Key, Key> keys = new ConcurrentHashMap<>();
 
     public void flush() {
         descriptors.clear();
     }
 
     public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
-        return new CacheKey(plugin, repositories, session);
+        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
     }
 
     public PluginDescriptor get(Key cacheKey) {
@@ -66,26 +67,20 @@ public PluginDescriptor get(Key cacheKey) {
     @Override
     public PluginDescriptor get(Key key, PluginDescriptorSupplier supplier)
             throws PluginDescriptorParsingException, PluginResolutionException, InvalidPluginDescriptorException {
+
         try {
-            return clone(descriptors.computeIfAbsent(key, k -> {
-                try {
-                    return clone(supplier.load());
-                } catch (PluginDescriptorParsingException
-                        | PluginResolutionException
-                        | InvalidPluginDescriptorException e) {
-                    throw new RuntimeException(e);
+            PluginDescriptor desc = descriptors.get(key);
+            if (desc == null) {
+                synchronized (key) {
+                    desc = descriptors.get(key);
+                    if (desc == null) {
+                        desc = supplier.load();
+                        descriptors.putIfAbsent(key, clone(desc));
+                    }
                 }
-            }));
-        } catch (RuntimeException e) {
-            if (e.getCause() instanceof PluginDescriptorParsingException) {
-                throw (PluginDescriptorParsingException) e.getCause();
-            }
-            if (e.getCause() instanceof PluginResolutionException) {
-                throw (PluginResolutionException) e.getCause();
-            }
-            if (e.getCause() instanceof InvalidPluginDescriptorException) {
-                throw (InvalidPluginDescriptorException) e.getCause();
             }
+            return clone(desc);
+        } catch (PluginDescriptorParsingException | PluginResolutionException | InvalidPluginDescriptorException e) {
             throw e;
         }
     }

maven-core/src/main/java/org/apache/maven/project/artifact/DefaultProjectArtifactsCache.java

@@ -161,6 +161,7 @@ public boolean equals(Object o) {
     }
 
     protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();
+    protected final Map<Key, Key> keys = new ConcurrentHashMap<>();
 
     @Override
     public Key createKey(
@@ -169,13 +170,14 @@ public Key createKey(
             Collection<String> scopesToResolve,
             boolean aggregating,
             RepositorySystemSession session) {
-        return new CacheKey(
+        Key key = new CacheKey(
                 project,
                 project.getRemoteProjectRepositories(),
                 scopesToCollect,
                 scopesToResolve,
                 aggregating,
                 session);
+        return keys.computeIfAbsent(key, k -> k);
     }
 
     @Override