Как происходит подъем контекста

Подъём контекста (Context Hoisting) в Java

Подъём контекста — это процесс, при котором переменные, объекты или состояние, определённые во внутренней области видимости, становятся доступны в области более высокого уровня. Это фундаментальный механизм как в синхронном, так и в асинхронном программировании на Java, особенно важный при работе с потоками и async-операциями.

Концепция в однопоточном контексте

В обычном Java-коде контекст автоматически передаётся между методами через стек вызовов:

public class ContextExample {
    public static void main(String[] args) {
        String userContext = "currentUser";
        processRequest(userContext);
    }
    
    public static void processRequest(String context) {
        // Контекст передан через параметр
        System.out.println("Processing: " + context);
        executeLogic(context);
    }
    
    public static void executeLogic(String context) {
        // Контекст доступен на любой глубине
        System.out.println("Executing with context: " + context);
    }
}

Проблема в многопоточной среде

Когда работаем с потоками, контекст не передаётся автоматически. Каждый поток имеет собственный стек, и переменные из родительского потока недоступны:

public class ThreadContextProblem {
    public static void main(String[] args) {
        String userId = "user123";
        
        new Thread(() -> {
            // userId доступна как финальная переменная
            // но это не полноценный "контекст"
            System.out.println(userId);
        }).start();
    }
}

Решение 1: ThreadLocal для хранения контекста

ThreadLocal позволяет хранить данные, уникальные для каждого потока, и автоматически передавать их по цепочке вызовов внутри одного потока:

public class ContextHolder {
    private static final ThreadLocal<String> userContext = new ThreadLocal<>();
    
    public static void setUser(String user) {
        userContext.set(user);
    }
    
    public static String getUser() {
        return userContext.get();
    }
    
    public static void clear() {
        userContext.remove();
    }
}

public class RequestHandler {
    public void handleRequest(String userId) {
        ContextHolder.setUser(userId);
        try {
            processRequest();
            executeLogic();
        } finally {
            ContextHolder.clear(); // ВАЖНО: избегаем утечек памяти
        }
    }
    
    private void processRequest() {
        String user = ContextHolder.getUser();
        System.out.println("Processing for: " + user);
    }
    
    private void executeLogic() {
        String user = ContextHolder.getUser();
        System.out.println("Executing for: " + user);
    }
}

Проблема ThreadLocal в async-кода (Project Loom)

С появлением virtual threads (проект Loom, Java 21+), ThreadLocal может создавать проблемы, так как virtual thread может переключаться между platform threads:

// Java 21+ с virtual threads
var virtualThread = Thread.ofVirtual().start(() -> {
    String context = ContextHolder.getUser();
    // Потенциальная проблема: контекст может быть потерян
    // при переключении на другой platform thread
});

Решение 2: ScopedValue (Java 21+)

ScopedValue — современное решение, специально разработанное для virtual threads и асинхронного кода:

public class ModernContext {
    static final ScopedValue<String> USER_CONTEXT = ScopedValue.newInstance();
    
    public static void main(String[] args) throws Exception {
        String userId = "user123";
        
        ScopedValue.where(USER_CONTEXT, userId)
            .run(() -> {
                // Контекст доступен здесь
                processRequest();
            });
    }
    
    static void processRequest() {
        String user = USER_CONTEXT.get();
        System.out.println("Processing: " + user);
    }
}

Решение 3: Контекст в Spring (RequestContext)

Spring автоматически управляет контекстом запроса через RequestContextHolder:

@RestController
public class UserController {
    
    @GetMapping("/user")
    public String getUser() {
        // Spring хранит контекст запроса
        ServletRequestAttributes attrs = (ServletRequestAttributes) 
            RequestContextHolder.getRequestAttributes();
        
        HttpServletRequest request = attrs.getRequest();
        String userId = request.getHeader("X-User-Id");
        
        return processUserData(userId);
    }
    
    private String processUserData(String userId) {
        // Контекст доступен в любом методе
        String user = (String) RequestContextHolder
            .getRequestAttributes()
            .getAttribute("userId", RequestAttributes.SCOPE_REQUEST);
        return user;
    }
}

Лучшие практики

1. Используй ThreadLocal в синхронном коде — передача контекста по цепочке вызовов
2. Всегда очищай ThreadLocal — избегай утечек памяти в потокпулах
3. Переходи на ScopedValue в Java 21+ — безопаснее для virtual threads
4. В Spring используй встроенные механизмы — RequestContextHolder, Authentication в SecurityContext
5. Избегай передачи контекста как параметра — использование ThreadLocal/ScopedValue чище

Подъём контекста — это критический паттерн для построения масштабируемых многопоточных приложений, особенно при обработке множества параллельных операций.