+ + {static} set(context : UserContext) : void
+ + {static} get() : UserContext
+ + {static} clear() : void
+}
+class RequestHandler {
+ - contextProxy : UserContextProxy
+ - token : String
+ + RequestHandler(contextProxy : UserContextProxy, token : String)
+ + process() : void
+ - parseToken(token : String) : Long
+}
+class APP {
+ + {static} main(args : String[]) : void
+}
+class Thread {
+ + start() : void
+}
+
+UserContextProxy ..> UserContext : manages
+RequestHandler ..> UserContextProxy : uses
+RequestHandler ..> UserContext : creates
+APP ..> UserContextProxy : creates
+APP ..> RequestHandler : creates
+APP ..> Thread : starts
+Thread ..> RequestHandler : executes
+@enduml
\ No newline at end of file
diff --git a/thread-specific-storage/pom.xml b/thread-specific-storage/pom.xml
new file mode 100644
index 000000000000..6e54c3fc406f
--- /dev/null
+++ b/thread-specific-storage/pom.xml
@@ -0,0 +1,83 @@
+
+
+
+
+ 4.0.0
+
+
+ com.iluwatar
+ java-design-patterns
+ 1.26.0-SNAPSHOT
+
+
+ thread-specific-storage
+
+
+
+ org.slf4j
+ slf4j-api
+
+
+ ch.qos.logback
+ logback-classic
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ test
+
+
+ org.mockito
+ mockito-core
+ test
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-assembly-plugin
+
+
+
+
+
+ com.iluwatar.threadspecificstorage.App
+
+
+
+
+
+
+
+
+
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
new file mode 100644
index 000000000000..882852ef4c49
--- /dev/null
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
@@ -0,0 +1,40 @@
+package com.iluwatar.threadspecificstorage;
+
+/**
+ * Application entry point demonstrating the Thread-Specific Storage pattern.
+ *
+ * This example simulates concurrent request processing for multiple users.
+ * Each request carries a user token, and user-specific context is managed
+ * transparently using thread-specific storage.
+ */
+public class App {
+
+ /**
+ * Runs the Thread-Specific Storage pattern demonstration.
+ *
+ * @param args command-line arguments (not used)
+ */
+ public static void main(String[] args) {
+ // Initialize components
+ UserContextProxy proxy = new UserContextProxy();
+
+ // Simulate concurrent requests from multiple users
+ for (int i = 1; i <= 5; i++) {
+ // Simulate tokens for different users
+ String token = "token::" + (i % 3 + 1); // 3 distinct users
+
+ new Thread(() -> {
+ // Simulate request processing flow
+ RequestHandler handler = new RequestHandler(proxy, token);
+ handler.process();
+ }).start();
+
+ // Slightly stagger request times
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
new file mode 100644
index 000000000000..6be42db5f62a
--- /dev/null
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
@@ -0,0 +1,58 @@
+package com.iluwatar.threadspecificstorage;
+
+import java.util.Random;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Application Thread
+ *
+ * Each instance simulates a request-processing thread that uses
+ * the Thread-Specific Object Proxy to access Thread-Specific Object.
+ */
+@AllArgsConstructor
+@Slf4j
+public class RequestHandler {
+ private final UserContextProxy contextProxy;
+ private final String token;
+
+ /**
+ * Simulated business process:
+ * 1. Parse userId from token ("Token::userId").
+ * 2. Store userId in thread-local storage.
+ * 3. Later, retrieve userId and use it for business logic.
+ * 4. Finally, clear thread-local to prevent memory leak.
+ */
+ public void process() {
+ LOGGER.info("Start handling request with token: {}", token);
+
+ try {
+ // Step 1: Parse token to get userId
+ Long userId = parseToken(token);
+
+ // Step 2: Save userId in ThreadLocal storage
+ contextProxy.set(new UserContext(userId));
+
+ // Simulate delay between stages of request handling
+ Thread.sleep(200);
+
+ // Step 3: Retrieve userId later in the request flow
+ Long retrievedId = contextProxy.get().getUserId();
+ Random random = new Random();
+ String accountInfo = retrievedId + "'s account: " + random.nextInt(400);
+ LOGGER.info(accountInfo);
+
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ } finally {
+ // Step 4: Clear ThreadLocal to avoid potential memory leaks
+ contextProxy.clear();
+ }
+ }
+
+ private Long parseToken(String token) {
+ // token format: "Token::1234"
+ String[] parts = token.split("::");
+ return (parts.length == 2) ? Long.parseLong(parts[1]) : -1L;
+ }
+}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContext.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContext.java
new file mode 100644
index 000000000000..51399a1a0c72
--- /dev/null
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContext.java
@@ -0,0 +1,15 @@
+package com.iluwatar.threadspecificstorage;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+/**
+ * Thread-Specific Object
+ *
+ *
Provides a service or data that is only accessible via a particular thread.
+ */
+@Data
+@AllArgsConstructor
+public class UserContext {
+ private Long userId;
+}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
new file mode 100644
index 000000000000..ca5e15e93919
--- /dev/null
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
@@ -0,0 +1,35 @@
+package com.iluwatar.threadspecificstorage;
+
+/**
+ * Thread-Specific Object Proxy
+ *
+ *
The Thread-Specific Object Proxy acts as an intermediary,
+ * enabling application thread to access and manipulate thread-specific objects simply and securely.
+ */
+public class UserContextProxy {
+ /**
+ * Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.This ThreadLocal acts as the Key for the map.So That there is also no key factory.
+ */
+ private static final ThreadLocal userContextHolder = new ThreadLocal();
+
+ /**
+ * Set UserContext for the current thread.
+ */
+ public static void set(UserContext context) {
+ userContextHolder.set(context);
+ }
+
+ /**
+ * Get UserContext for the current thread.
+ */
+ public static UserContext get() {
+ return userContextHolder.get();
+ }
+
+ /**
+ * Clear UserContext to prevent potential memory leaks.
+ */
+ public static void clear() {
+ userContextHolder.remove();
+ }
+}
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
new file mode 100644
index 000000000000..0a01ee3be2ba
--- /dev/null
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
@@ -0,0 +1,38 @@
+package com.iluwatar.threadspecificstorage;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests for APP class
+ */
+class AppTest {
+ @Test
+ void testMainMethod() {
+ // Capture system output
+ ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(outContent));
+
+ // Run the main method
+ App.main(new String[]{});
+
+ // Give some time for threads to execute
+ try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+
+ // Verify output contains expected log messages
+ String output = outContent.toString();
+ assertTrue(output.contains("Start handling request with token"),
+ "Should contain request handling start messages");
+
+ // Restore system output
+ System.setOut(System.out);
+ }
+}
\ No newline at end of file
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
new file mode 100644
index 000000000000..6afbaf7f0178
--- /dev/null
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
@@ -0,0 +1,34 @@
+package com.iluwatar.threadspecificstorage;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RequestHandlerTest {
+
+ @Test
+ void process_shouldStoreAndClearUserContext() {
+ // Given - a real UserContextProxy
+ UserContextProxy proxy = new UserContextProxy();
+ RequestHandler handler = new RequestHandler(proxy, "token::123");
+
+ // When - process the request
+ handler.process();
+
+ // Then - after processing, ThreadLocal should be cleared
+ assertNull(proxy.get(), "ThreadLocal should be cleared after process()");
+ }
+
+ @Test
+ void process_withInvalidToken_shouldSetUserIdToMinusOne() {
+ // Given - a real UserContextProxy
+ UserContextProxy proxy = new UserContextProxy();
+ RequestHandler handler = new RequestHandler(proxy, "invalid-token");
+
+ // When - process the request
+ handler.process();
+
+ // Then - after processing, ThreadLocal should be cleared
+ assertNull(proxy.get(), "ThreadLocal should be cleared even for invalid token");
+ }
+}
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java
new file mode 100644
index 000000000000..56eb44ad4d15
--- /dev/null
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java
@@ -0,0 +1,68 @@
+package com.iluwatar.threadspecificstorage;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for UserContextProxy class
+ */
+class UserContextProxyTest {
+
+ private UserContext userContext;
+
+ @BeforeEach
+ void setUp() {
+ userContext = new UserContext(123L);
+ }
+
+ @AfterEach
+ void tearDown() {
+ UserContextProxy.clear();
+ }
+
+ @Test
+ void testSetAndGetContext() {
+ UserContextProxy.set(userContext);
+ UserContext retrievedContext = UserContextProxy.get();
+ assertNotNull(retrievedContext, "Retrieved context should not be null");
+ assertEquals(userContext.getUserId(), retrievedContext.getUserId(),
+ "Retrieved context should have the same userId");
+ }
+
+ @Test
+ void testGetContextWhenNotSet() {
+ UserContext retrievedContext = UserContextProxy.get();
+ assertNull(retrievedContext, "Context should be null when not set");
+ }
+
+ @Test
+ void testClearContext() {
+ UserContextProxy.set(userContext);
+ UserContextProxy.clear();
+ UserContext retrievedContext = UserContextProxy.get();
+ assertNull(retrievedContext, "Context should be null after clearing");
+ }
+
+ @Test
+ void testThreadIsolation() throws InterruptedException {
+ UserContext context1 = new UserContext(123L);
+ UserContext context2 = new UserContext(456L);
+ UserContextProxy.set(context1);
+ // Create another thread to set different context
+ Thread thread = new Thread(() -> {
+ UserContextProxy.set(context2);
+ UserContext threadContext = UserContextProxy.get();
+ assertNotNull(threadContext);
+ assertEquals(456L, threadContext.getUserId());
+ });
+ thread.start();
+ thread.join();
+ // Main thread context should remain unchanged
+ UserContext mainThreadContext = UserContextProxy.get();
+ assertNotNull(mainThreadContext);
+ assertEquals(123L, mainThreadContext.getUserId());
+ }
+}
\ No newline at end of file
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java
new file mode 100644
index 000000000000..636e8bfcdc2a
--- /dev/null
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java
@@ -0,0 +1,51 @@
+package com.iluwatar.threadspecificstorage;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for UserContext class
+ */
+class UserContextTest {
+
+ @Test
+ void testConstructorAndGetUserId() {
+ Long userId = 123L;
+ UserContext context = new UserContext(userId);
+
+ assertEquals(userId, context.getUserId(), "UserId should match the one provided in constructor");
+ }
+
+ @Test
+ void testSetUserId() {
+ UserContext context = new UserContext(123L);
+ Long newUserId = 456L;
+
+ context.setUserId(newUserId);
+
+ assertEquals(newUserId, context.getUserId(), "UserId should be updated");
+ }
+
+ @Test
+ void testToString() {
+ Long userId = 123L;
+ UserContext context = new UserContext(userId);
+
+ String expected = "UserContext(userId=" + userId + ")";
+ assertEquals(expected, context.toString(), "toString should return expected format");
+ }
+
+ @Test
+ void testEqualsAndHashCode() {
+ Long userId = 123L;
+ UserContext context1 = new UserContext(userId);
+ UserContext context2 = new UserContext(userId);
+ UserContext context3 = new UserContext(456L);
+
+ assertEquals(context1, context2, "Objects with same userId should be equal");
+ assertEquals(context1.hashCode(), context2.hashCode(), "Objects with same userId should have same hashCode");
+
+ assertNotEquals(context1, context3, "Objects with different userId should not be equal");
+ assertNotEquals(context1.hashCode(), context3.hashCode(), "Objects with different userId should have different hashCode");
+ }
+}
\ No newline at end of file
From 5d8581ac319bd95311148b25aa53ab62fa88c1cd Mon Sep 17 00:00:00 2001
From: CMD137 <2992456841@qq.com>
Date: Fri, 23 Jan 2026 00:42:25 +0800
Subject: [PATCH 2/7] fixed:pom.xml Run 'mvn spotless:apply' to fix these
violations.
---
pom.xml | 2 +-
.../iluwatar/threadspecificstorage/App.java | 17 +++++------
.../threadspecificstorage/RequestHandler.java | 12 ++++----
.../UserContextProxy.java | 19 +++++--------
.../threadspecificstorage/AppTest.java | 16 +++++------
.../RequestHandlerTest.java | 4 +--
.../UserContextProxyTest.java | 28 ++++++++++---------
.../UserContextTest.java | 22 +++++++++------
8 files changed, 60 insertions(+), 60 deletions(-)
diff --git a/pom.xml b/pom.xml
index 05884a780537..92b5da5460ce 100644
--- a/pom.xml
+++ b/pom.xml
@@ -231,7 +231,7 @@
table-module
template-method
templateview
- thread-pool-executor
+ thread-pool-executor
thread-specific-storage
throttling
tolerant-reader
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
index 882852ef4c49..8d784787eede 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
@@ -3,9 +3,8 @@
/**
* Application entry point demonstrating the Thread-Specific Storage pattern.
*
- * This example simulates concurrent request processing for multiple users.
- * Each request carries a user token, and user-specific context is managed
- * transparently using thread-specific storage.
+ * This example simulates concurrent request processing for multiple users. Each request carries
+ * a user token, and user-specific context is managed transparently using thread-specific storage.
*/
public class App {
@@ -23,11 +22,13 @@ public static void main(String[] args) {
// Simulate tokens for different users
String token = "token::" + (i % 3 + 1); // 3 distinct users
- new Thread(() -> {
- // Simulate request processing flow
- RequestHandler handler = new RequestHandler(proxy, token);
- handler.process();
- }).start();
+ new Thread(
+ () -> {
+ // Simulate request processing flow
+ RequestHandler handler = new RequestHandler(proxy, token);
+ handler.process();
+ })
+ .start();
// Slightly stagger request times
try {
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
index 6be42db5f62a..eca0001a0e51 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
@@ -7,8 +7,8 @@
/**
* Application Thread
*
- *
Each instance simulates a request-processing thread that uses
- * the Thread-Specific Object Proxy to access Thread-Specific Object.
+ *
Each instance simulates a request-processing thread that uses the Thread-Specific Object Proxy
+ * to access Thread-Specific Object.
*/
@AllArgsConstructor
@Slf4j
@@ -17,11 +17,9 @@ public class RequestHandler {
private final String token;
/**
- * Simulated business process:
- * 1. Parse userId from token ("Token::userId").
- * 2. Store userId in thread-local storage.
- * 3. Later, retrieve userId and use it for business logic.
- * 4. Finally, clear thread-local to prevent memory leak.
+ * Simulated business process: 1. Parse userId from token ("Token::userId"). 2. Store userId in
+ * thread-local storage. 3. Later, retrieve userId and use it for business logic. 4. Finally,
+ * clear thread-local to prevent memory leak.
*/
public void process() {
LOGGER.info("Start handling request with token: {}", token);
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
index ca5e15e93919..998fc514bbf4 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
@@ -3,32 +3,27 @@
/**
* Thread-Specific Object Proxy
*
- *
The Thread-Specific Object Proxy acts as an intermediary,
- * enabling application thread to access and manipulate thread-specific objects simply and securely.
+ *
The Thread-Specific Object Proxy acts as an intermediary, enabling application thread to
+ * access and manipulate thread-specific objects simply and securely.
*/
public class UserContextProxy {
/**
- * Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.This ThreadLocal acts as the Key for the map.So That there is also no key factory.
+ * Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.This ThreadLocal acts as the Key
+ * for the map.So That there is also no key factory.
*/
private static final ThreadLocal userContextHolder = new ThreadLocal();
- /**
- * Set UserContext for the current thread.
- */
+ /** Set UserContext for the current thread. */
public static void set(UserContext context) {
userContextHolder.set(context);
}
- /**
- * Get UserContext for the current thread.
- */
+ /** Get UserContext for the current thread. */
public static UserContext get() {
return userContextHolder.get();
}
- /**
- * Clear UserContext to prevent potential memory leaks.
- */
+ /** Clear UserContext to prevent potential memory leaks. */
public static void clear() {
userContextHolder.remove();
}
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
index 0a01ee3be2ba..143c57541b49 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
@@ -1,15 +1,12 @@
package com.iluwatar.threadspecificstorage;
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
+import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * Tests for APP class
- */
+/** Tests for APP class */
class AppTest {
@Test
void testMainMethod() {
@@ -18,7 +15,7 @@ void testMainMethod() {
System.setOut(new PrintStream(outContent));
// Run the main method
- App.main(new String[]{});
+ App.main(new String[] {});
// Give some time for threads to execute
try {
@@ -29,10 +26,11 @@ void testMainMethod() {
// Verify output contains expected log messages
String output = outContent.toString();
- assertTrue(output.contains("Start handling request with token"),
+ assertTrue(
+ output.contains("Start handling request with token"),
"Should contain request handling start messages");
// Restore system output
System.setOut(System.out);
}
-}
\ No newline at end of file
+}
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
index 6afbaf7f0178..e58cbb4a5661 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
@@ -1,9 +1,9 @@
package com.iluwatar.threadspecificstorage;
-import org.junit.jupiter.api.Test;
-
import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
class RequestHandlerTest {
@Test
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java
index 56eb44ad4d15..fd8cfbd6b7aa 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextProxyTest.java
@@ -1,14 +1,12 @@
package com.iluwatar.threadspecificstorage;
+import static org.junit.jupiter.api.Assertions.*;
+
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for UserContextProxy class
- */
+/** Tests for UserContextProxy class */
class UserContextProxyTest {
private UserContext userContext;
@@ -28,7 +26,9 @@ void testSetAndGetContext() {
UserContextProxy.set(userContext);
UserContext retrievedContext = UserContextProxy.get();
assertNotNull(retrievedContext, "Retrieved context should not be null");
- assertEquals(userContext.getUserId(), retrievedContext.getUserId(),
+ assertEquals(
+ userContext.getUserId(),
+ retrievedContext.getUserId(),
"Retrieved context should have the same userId");
}
@@ -52,12 +52,14 @@ void testThreadIsolation() throws InterruptedException {
UserContext context2 = new UserContext(456L);
UserContextProxy.set(context1);
// Create another thread to set different context
- Thread thread = new Thread(() -> {
- UserContextProxy.set(context2);
- UserContext threadContext = UserContextProxy.get();
- assertNotNull(threadContext);
- assertEquals(456L, threadContext.getUserId());
- });
+ Thread thread =
+ new Thread(
+ () -> {
+ UserContextProxy.set(context2);
+ UserContext threadContext = UserContextProxy.get();
+ assertNotNull(threadContext);
+ assertEquals(456L, threadContext.getUserId());
+ });
thread.start();
thread.join();
// Main thread context should remain unchanged
@@ -65,4 +67,4 @@ void testThreadIsolation() throws InterruptedException {
assertNotNull(mainThreadContext);
assertEquals(123L, mainThreadContext.getUserId());
}
-}
\ No newline at end of file
+}
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java
index 636e8bfcdc2a..3a7864c9e92e 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/UserContextTest.java
@@ -1,11 +1,10 @@
package com.iluwatar.threadspecificstorage;
-import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
-/**
- * Tests for UserContext class
- */
+import org.junit.jupiter.api.Test;
+
+/** Tests for UserContext class */
class UserContextTest {
@Test
@@ -13,7 +12,8 @@ void testConstructorAndGetUserId() {
Long userId = 123L;
UserContext context = new UserContext(userId);
- assertEquals(userId, context.getUserId(), "UserId should match the one provided in constructor");
+ assertEquals(
+ userId, context.getUserId(), "UserId should match the one provided in constructor");
}
@Test
@@ -43,9 +43,15 @@ void testEqualsAndHashCode() {
UserContext context3 = new UserContext(456L);
assertEquals(context1, context2, "Objects with same userId should be equal");
- assertEquals(context1.hashCode(), context2.hashCode(), "Objects with same userId should have same hashCode");
+ assertEquals(
+ context1.hashCode(),
+ context2.hashCode(),
+ "Objects with same userId should have same hashCode");
assertNotEquals(context1, context3, "Objects with different userId should not be equal");
- assertNotEquals(context1.hashCode(), context3.hashCode(), "Objects with different userId should have different hashCode");
+ assertNotEquals(
+ context1.hashCode(),
+ context3.hashCode(),
+ "Objects with different userId should have different hashCode");
}
-}
\ No newline at end of file
+}
From 34cc03f6bb576f4cd466743f05c0f94417d122bb Mon Sep 17 00:00:00 2001
From: CMD137 <2992456841@qq.com>
Date: Fri, 23 Jan 2026 01:30:20 +0800
Subject: [PATCH 3/7] fix: address Sonar security hotspots for Random usage and
e.printStackTrace()
---
.../main/java/com/iluwatar/threadspecificstorage/App.java | 5 ++++-
.../com/iluwatar/threadspecificstorage/RequestHandler.java | 3 ++-
2 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
index 8d784787eede..2de8c837dd90 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
@@ -1,11 +1,14 @@
package com.iluwatar.threadspecificstorage;
+import lombok.extern.slf4j.Slf4j;
+
/**
* Application entry point demonstrating the Thread-Specific Storage pattern.
*
* This example simulates concurrent request processing for multiple users. Each request carries
* a user token, and user-specific context is managed transparently using thread-specific storage.
*/
+@Slf4j
public class App {
/**
@@ -34,7 +37,7 @@ public static void main(String[] args) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
- e.printStackTrace();
+ LOGGER.warn("Sleep interrupted", e);
}
}
}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
index eca0001a0e51..3aa2aa75b913 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
@@ -1,5 +1,6 @@
package com.iluwatar.threadspecificstorage;
+import java.security.SecureRandom;
import java.util.Random;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -36,7 +37,7 @@ public void process() {
// Step 3: Retrieve userId later in the request flow
Long retrievedId = contextProxy.get().getUserId();
- Random random = new Random();
+ SecureRandom random = new SecureRandom();
String accountInfo = retrievedId + "'s account: " + random.nextInt(400);
LOGGER.info(accountInfo);
From 106f06d8080aba527063a48c19a894b96d2f6dd4 Mon Sep 17 00:00:00 2001
From: CMD137 <2992456841@qq.com>
Date: Fri, 23 Jan 2026 01:52:19 +0800
Subject: [PATCH 4/7] fixed: Run 'mvn spotless:apply'(remove unused import)
---
.../java/com/iluwatar/threadspecificstorage/RequestHandler.java | 1 -
1 file changed, 1 deletion(-)
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
index 3aa2aa75b913..719c663c0641 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
@@ -1,7 +1,6 @@
package com.iluwatar.threadspecificstorage;
import java.security.SecureRandom;
-import java.util.Random;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
From d3a8041057948fc91ee5eb339b1defc5babd3b32 Mon Sep 17 00:00:00 2001
From: CMD137 <2992456841@qq.com>
Date: Fri, 23 Jan 2026 11:27:24 +0800
Subject: [PATCH 5/7] fixed: Refactor Thread-Specific Storage pattern
implementation to address Sonar issues: remove unnecessary instantiation, add
private constructor, use diamond operator, and update tests.
---
thread-specific-storage/pom.xml | 6 ++++++
.../com/iluwatar/threadspecificstorage/App.java | 6 ++----
.../threadspecificstorage/RequestHandler.java | 13 +++++++------
.../threadspecificstorage/UserContextProxy.java | 5 ++++-
.../iluwatar/threadspecificstorage/AppTest.java | 12 +++++++-----
.../threadspecificstorage/RequestHandlerTest.java | 14 ++++++--------
6 files changed, 32 insertions(+), 24 deletions(-)
diff --git a/thread-specific-storage/pom.xml b/thread-specific-storage/pom.xml
index 6e54c3fc406f..1af91514369b 100644
--- a/thread-specific-storage/pom.xml
+++ b/thread-specific-storage/pom.xml
@@ -59,6 +59,12 @@
mockito-core
test
+
+ org.awaitility
+ awaitility
+ 4.2.1
+ test
+
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
index 2de8c837dd90..a84388acfe08 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java
@@ -17,9 +17,6 @@ public class App {
* @param args command-line arguments (not used)
*/
public static void main(String[] args) {
- // Initialize components
- UserContextProxy proxy = new UserContextProxy();
-
// Simulate concurrent requests from multiple users
for (int i = 1; i <= 5; i++) {
// Simulate tokens for different users
@@ -28,7 +25,7 @@ public static void main(String[] args) {
new Thread(
() -> {
// Simulate request processing flow
- RequestHandler handler = new RequestHandler(proxy, token);
+ RequestHandler handler = new RequestHandler(token);
handler.process();
})
.start();
@@ -37,6 +34,7 @@ public static void main(String[] args) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
LOGGER.warn("Sleep interrupted", e);
}
}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
index 719c663c0641..d5f2cca2830d 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java
@@ -1,7 +1,6 @@
package com.iluwatar.threadspecificstorage;
import java.security.SecureRandom;
-import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
@@ -10,12 +9,14 @@
* Each instance simulates a request-processing thread that uses the Thread-Specific Object Proxy
* to access Thread-Specific Object.
*/
-@AllArgsConstructor
@Slf4j
public class RequestHandler {
- private final UserContextProxy contextProxy;
private final String token;
+ public RequestHandler(String token) {
+ this.token = token;
+ }
+
/**
* Simulated business process: 1. Parse userId from token ("Token::userId"). 2. Store userId in
* thread-local storage. 3. Later, retrieve userId and use it for business logic. 4. Finally,
@@ -29,13 +30,13 @@ public void process() {
Long userId = parseToken(token);
// Step 2: Save userId in ThreadLocal storage
- contextProxy.set(new UserContext(userId));
+ UserContextProxy.set(new UserContext(userId));
// Simulate delay between stages of request handling
Thread.sleep(200);
// Step 3: Retrieve userId later in the request flow
- Long retrievedId = contextProxy.get().getUserId();
+ Long retrievedId = UserContextProxy.get().getUserId();
SecureRandom random = new SecureRandom();
String accountInfo = retrievedId + "'s account: " + random.nextInt(400);
LOGGER.info(accountInfo);
@@ -44,7 +45,7 @@ public void process() {
Thread.currentThread().interrupt();
} finally {
// Step 4: Clear ThreadLocal to avoid potential memory leaks
- contextProxy.clear();
+ UserContextProxy.clear();
}
}
diff --git a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
index 998fc514bbf4..468e554b0bf6 100644
--- a/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
+++ b/thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java
@@ -11,7 +11,10 @@ public class UserContextProxy {
* Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.This ThreadLocal acts as the Key
* for the map.So That there is also no key factory.
*/
- private static final ThreadLocal userContextHolder = new ThreadLocal();
+ private static final ThreadLocal userContextHolder = new ThreadLocal<>();
+
+ /** Private constructor to prevent instantiation of this utility class. */
+ private UserContextProxy() {}
/** Set UserContext for the current thread. */
public static void set(UserContext context) {
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
index 143c57541b49..775ded85b8ea 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java
@@ -1,5 +1,8 @@
package com.iluwatar.threadspecificstorage;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.awaitility.Awaitility.await;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayOutputStream;
@@ -18,11 +21,10 @@ void testMainMethod() {
App.main(new String[] {});
// Give some time for threads to execute
- try {
- Thread.sleep(2000);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- }
+ await()
+ .atMost(5, SECONDS)
+ .pollInterval(100, MILLISECONDS)
+ .until(() -> outContent.toString().contains("Start handling request with token"));
// Verify output contains expected log messages
String output = outContent.toString();
diff --git a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
index e58cbb4a5661..e5f5968e7794 100644
--- a/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
+++ b/thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java
@@ -8,27 +8,25 @@ class RequestHandlerTest {
@Test
void process_shouldStoreAndClearUserContext() {
- // Given - a real UserContextProxy
- UserContextProxy proxy = new UserContextProxy();
- RequestHandler handler = new RequestHandler(proxy, "token::123");
+ // Given - a request handler without proxy parameter
+ RequestHandler handler = new RequestHandler("token::123");
// When - process the request
handler.process();
// Then - after processing, ThreadLocal should be cleared
- assertNull(proxy.get(), "ThreadLocal should be cleared after process()");
+ assertNull(UserContextProxy.get(), "ThreadLocal should be cleared after process()");
}
@Test
void process_withInvalidToken_shouldSetUserIdToMinusOne() {
- // Given - a real UserContextProxy
- UserContextProxy proxy = new UserContextProxy();
- RequestHandler handler = new RequestHandler(proxy, "invalid-token");
+ // Given - a request handler without proxy parameter
+ RequestHandler handler = new RequestHandler("invalid-token");
// When - process the request
handler.process();
// Then - after processing, ThreadLocal should be cleared
- assertNull(proxy.get(), "ThreadLocal should be cleared even for invalid token");
+ assertNull(UserContextProxy.get(), "ThreadLocal should be cleared even for invalid token");
}
}
From 1bc4eddd836b9b814429af738d9bbe555bdee954 Mon Sep 17 00:00:00 2001
From: CMD137 <2992456841@qq.com>
Date: Fri, 23 Jan 2026 12:20:07 +0800
Subject: [PATCH 6/7] fixed: update uml and README.md
---
thread-specific-storage/README.md | 25 +++---
.../etc/ThreadSpecificStorageUML.png | Bin 28087 -> 24939 bytes
.../etc/thread-specific-storage.urm.puml | 72 +++++++++---------
3 files changed, 53 insertions(+), 44 deletions(-)
diff --git a/thread-specific-storage/README.md b/thread-specific-storage/README.md
index a08b1f6af199..e3109595fd84 100644
--- a/thread-specific-storage/README.md
+++ b/thread-specific-storage/README.md
@@ -63,9 +63,6 @@ of the user context data.
@Slf4j
public class APP {
public static void main(String[] args) {
- // Initialize components
- UserContextProxy proxy = new UserContextProxy();
-
// Simulate concurrent requests from multiple users
for (int i = 1; i <= 5; i++) {
// Simulate tokens for different users
@@ -73,7 +70,7 @@ public class APP {
new Thread(() -> {
// Simulate request processing flow
- RequestHandler handler = new RequestHandler(proxy, token);
+ RequestHandler handler = new RequestHandler(token);
handler.process();
}).start();
@@ -93,9 +90,12 @@ Here's how the request handler processes each request:
```java
@Slf4j
public class RequestHandler {
- private final UserContextProxy contextProxy;
private final String token;
+ public RequestHandler(String token) {
+ this.token = token;
+ }
+
public void process() {
LOGGER.info("Start handling request with token: {}", token);
@@ -104,13 +104,13 @@ public class RequestHandler {
Long userId = parseToken(token);
// Step 2: Save userId in ThreadLocal storage
- contextProxy.set(new UserContext(userId));
+ UserContextProxy.set(new UserContext(userId));
// Simulate delay between stages of request handling
Thread.sleep(200);
// Step 3: Retrieve userId later in the request flow
- Long retrievedId = contextProxy.get().getUserId();
+ Long retrievedId = UserContextProxy.get().getUserId();
Random random = new Random();
String accountInfo = retrievedId + "'s account: " + random.nextInt(400);
LOGGER.info(accountInfo);
@@ -119,7 +119,7 @@ public class RequestHandler {
Thread.currentThread().interrupt();
} finally {
// Step 4: Clear ThreadLocal to avoid potential memory leaks
- contextProxy.clear();
+ UserContextProxy.clear();
}
}
@@ -133,7 +133,12 @@ The UserContextProxy acts as a thread-safe accessor to the ThreadLocal storage:
public class UserContextProxy {
// Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.
// This ThreadLocal acts as the Key for the map.
- private static final ThreadLocal userContextHolder = new ThreadLocal();
+ private static final ThreadLocal userContextHolder = new ThreadLocal<>();
+
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private UserContextProxy() {}
/** Set UserContext for the current thread */
public static void set(UserContext context) {
@@ -219,4 +224,4 @@ Start handling request with token: token::2
* [Pattern-Oriented Software Architecture, Volume 2: Patterns for Concurrent and Networked Objects](https://www.amazon.com/Pattern-Oriented-Software-Architecture-Concurrent-Networked/dp/0471606952)
* [Java Documentation for ThreadLocal](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ThreadLocal.html)
-* [Java Concurrency in Practice](https://jcip.net/) by Brian Goetz
+* [Java Concurrency in Practice](https://jcip.net/) by Brian Goetz
\ No newline at end of file
diff --git a/thread-specific-storage/etc/ThreadSpecificStorageUML.png b/thread-specific-storage/etc/ThreadSpecificStorageUML.png
index 1d2e0d27d7702005daeb4607bcec352f8feddb5e..d4957dd1cc2a3a488979328616ec1671a2050675 100644
GIT binary patch
literal 24939
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