From a15274d43148afc131ac6a3f9ef9a974c7de58a1 Mon Sep 17 00:00:00 2001
From: Juergen Hoeller <juergen.hoeller@broadcom.com>
Date: Wed, 26 Nov 2025 17:20:11 +0100
Subject: [PATCH] Revise volatile access to singletonInstance field

For defensiveness against a singletonInstance/initialized visibility mismatch, we accept the locking overhead for pre-initialized null values (where we need the initialized field) in favor of a defensive fast path for non-null values (where we only need the singletonInstance field).

Closes gh-35905
---
 .../util/function/SingletonSupplier.java        | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/spring-core/src/main/java/org/springframework/util/function/SingletonSupplier.java b/spring-core/src/main/java/org/springframework/util/function/SingletonSupplier.java
index 79893dfb203..f001c2b2581 100644
--- a/spring-core/src/main/java/org/springframework/util/function/SingletonSupplier.java
+++ b/spring-core/src/main/java/org/springframework/util/function/SingletonSupplier.java
@@ -47,12 +47,13 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
 
 	private volatile @Nullable T singletonInstance;
 
-	private volatile boolean initialized;
+	private boolean initialized;
 
 	/**
-	 * Guards access to write operations on the {@code singletonInstance} field.
+	 * Guards access to write operations on the {@code singletonInstance} and
+	 * {@code initialized} fields.
 	 */
-	private final Lock writeLock = new ReentrantLock();
+	private final Lock initializationLock = new ReentrantLock();
 
 
 	/**
@@ -99,8 +100,12 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
 	@Override
 	public @Nullable T get() {
 		T instance = this.singletonInstance;
-		if (!this.initialized) {
-			this.writeLock.lock();
+		if (instance == null) {
+			// Either not initialized yet, or a pre-initialized null value ->
+			// specific determination follows within full initialization lock.
+			// Pre-initialized null values are rare, so we accept the locking
+			// overhead in favor of a defensive fast path for non-null values.
+			this.initializationLock.lock();
 			try {
 				instance = this.singletonInstance;
 				if (!this.initialized) {
@@ -115,7 +120,7 @@ public class SingletonSupplier<T extends @Nullable Object> implements Supplier<T
 				}
 			}
 			finally {
-				this.writeLock.unlock();
+				this.initializationLock.unlock();
 			}
 		}
 		return instance;