ThreadLocal ve ScopedValue — Havuzdaki Thread Neyi Hatırlıyor?

1
public final class CurrentCustomer {
2

3
    private static final ThreadLocal<String> CUSTOMER_NO = new ThreadLocal<>();
4

5
    private CurrentCustomer() {}
6

7
    public static void set(String customerNo) { CUSTOMER_NO.set(customerNo); }
8
    public static String get() { return CUSTOMER_NO.get(); }
9
    public static void clear() { CUSTOMER_NO.remove(); }
10
}

1
public class CurrentCustomerFilter implements Filter {
2

3
    @Override
4
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
5
            throws IOException, ServletException {
6
        // Set by the authentication filter from the verified token, never from a raw header.
7
        String customerNo = (String) request.getAttribute("customerNo");
8
        CurrentCustomer.set(customerNo);
9
        try {
10
            chain.doFilter(request, response);
11
        } finally {
12
            // The pooled thread must not carry this customer into the next request:
13
            // that request would see someone else's accounts.
14
            CurrentCustomer.clear();
15
        }
16
    }
17
}

1
public class ContextCopyingExecutor implements Executor {
2

3
    private final Executor delegate;
4

5
    public ContextCopyingExecutor(Executor delegate) {
6
        this.delegate = delegate;
7
    }
8

9
    @Override
10
    public void execute(Runnable task) {
11
        String customerNo = CurrentCustomer.get();  // captured on the submitting thread
12
        delegate.execute(() -> {
13
            CurrentCustomer.set(customerNo);        // installed on the worker thread
14
            try {
15
                task.run();
16
            } finally {
17
                CurrentCustomer.clear();
18
            }
19
        });
20
    }
21
}

1
// Java 25: ScopedValue is final. The binding exists only inside run(…).
2
public final class RequestContext {
3

4
    public static final ScopedValue<String> USER = ScopedValue.newInstance();
5

6
    private RequestContext() {}
7

8
    public static void handle(String user, Runnable request) {
9
        ScopedValue.where(USER, user).run(request);   // nothing to clean up afterwards
10
    }
11

12
    public static String user() {
13
        return USER.isBound() ? USER.get() : "anonymous";
14
    }
15
}

1
public class LeakDemo {
2

3
    public static void main(String[] args) throws Exception {
4
        try (var pool = Executors.newFixedThreadPool(1)) {       // one thread: every task reuses it
5
            pool.submit(() -> CurrentCustomer.set("C-100042")).get();   // request 1, no cleanup
6
            System.out.println(pool.submit(CurrentCustomer::get).get());   // C-100042 <- request 2 is someone else's!
7

8
            pool.submit(() -> {                                        // request 3, done right
9
                CurrentCustomer.set("C-200117");
10
                try { /* list accounts */ } finally { CurrentCustomer.clear(); }
11
            }).get();
12
            System.out.println(pool.submit(CurrentCustomer::get).get());   // null     <- clean
13
        }
14

15
        RequestContext.handle("C-300555", () -> System.out.println(RequestContext.user()));  // C-300555
16
        System.out.println(RequestContext.user());                                          // anonymous
17
    }
18
}