Tradičné vlákno:
┌──────────────────┐
│   OS Thread       │  ← 1 MB stack, drahý context switch
│   (platform)      │  ← Počet limitovaný OS (~2000-5000)
└──────────────────┘

Virtual Thread:
┌──────────────────┐
│  Virtual Thread   │  ← ~Few KB stack, lacný
│  (JVM managed)    │  ← Počet: milióny
│       │           │
│  ┌────▼────┐      │
│  │ Carrier │      │  ← Keď VT blokuje (I/O), JVM ho "unmountne"
│  │ Thread  │      │     a carrier thread obslúži iný VT
│  └─────────┘      │
└──────────────────┘

Event Loop (Netty):
┌──────────────────────────────────┐
│  Event Loop Thread (1-N cores)   │
│                                  │
│  Request A ──▶ Handler ──▶ DB   │
│  Request B ──▶ Handler ──▶ API  │  ← Všetko non-blocking
│  Request C ──▶ Handler ──▶ DB   │  ← Žiadne čakanie
│                                  │
│  Callback ◀── DB Response A     │
│  Callback ◀── API Response B    │
└──────────────────────────────────┘

// ✅ Virtual Threads: Čistý, čitateľný kód
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @GetMapping("/{id}")
    public OrderDto getOrder(@PathVariable Long id) {
        // Blocking call — ale JVM to rieši za vás
        Order order = orderRepository.findById(id)
            .orElseThrow(() -> new NotFoundException("Order not found"));

        // Ďalší blocking call
        Customer customer = customerService.getCustomer(order.getCustomerId());

        // Synchrónna logika
        return OrderDto.from(order, customer);
    }
}

// ❌ WebFlux: Zbytočná komplexita pre tento use-case
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @GetMapping("/{id}")
    public Mono<OrderDto> getOrder(@PathVariable Long id) {
        return orderRepository.findById(id)
            .switchIfEmpty(Mono.error(new NotFoundException("Order not found")))
            .flatMap(order ->
                customerService.getCustomer(order.getCustomerId())
                    .map(customer -> OrderDto.from(order, customer))
            );
    }
}

# application.yml — zapnúť Virtual Threads je jedna property
spring:
  threads:
    virtual:
      enabled: true

// WebFlux debugging: Čo sa stalo?
reactor.core.Exceptions$ErrorCallbackNotImplemented:
    java.lang.NullPointerException
    Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException:
    Error has been observed at the following site(s):
        *__checkpoint ⇢ Handler ...OrderController#getOrder(Long)
        |_ ...somewhere in the reactive pipeline...

// Virtual Threads debugging: Jasný stack trace
java.lang.NullPointerException: Cannot invoke "Customer.getName()"
    at com.app.service.OrderService.getOrder(OrderService.java:42)
    at com.app.controller.OrderController.getOrder(OrderController.java:28)

// ✅ WebFlux: Natívny streaming s backpressure
@GetMapping(value = "/stream/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<EventDto>> streamEvents() {
    return eventService.getEventStream()
        .map(event -> ServerSentEvent.<EventDto>builder()
            .id(String.valueOf(event.getId()))
            .event("update")
            .data(EventDto.from(event))
            .build()
        );
}

// ✅ WebFlux: GraphQL subscriptions sú reaktívne zo svojej podstaty
@DgsSubscription
public Publisher<Notification> onNotification(
        @InputArgument String userId) {

    return notificationService.getNotificationStream(userId)
        .filter(n -> n.getUserId().equals(userId));
}

// ✅ WebFlux: Elegantná kompozícia paralelných operácií
public Mono<DashboardDto> getDashboard(String userId) {
    Mono<UserProfile> profile = userService.getProfile(userId);
    Mono<List<Order>> orders = orderService.getRecentOrders(userId);
    Mono<WalletBalance> balance = walletService.getBalance(userId);
    Mono<List<Notification>> notifications = notificationService.getUnread(userId);

    return Mono.zip(profile, orders, balance, notifications)
        .map(tuple -> DashboardDto.builder()
            .profile(tuple.getT1())
            .orders(tuple.getT2())
            .balance(tuple.getT3())
            .notifications(tuple.getT4())
            .build()
        );
}

// ❌ PROBLÉM: synchronized blokuje carrier thread
public synchronized String getFromCache(String key) {
    // Virtual thread je "pinned" — carrier thread čaká
    return cache.get(key);
}

// ✅ RIEŠENIE: Použiť ReentrantLock
private final ReentrantLock lock = new ReentrantLock();

public String getFromCache(String key) {
    lock.lock();
    try {
        return cache.get(key);
    } finally {
        lock.unlock();
    }
}

// ❌ PROBLÉM: 100 000 virtual threads, ale len 50 DB connections
// Výsledok: 99 950 threadov čaká na connection

// ✅ RIEŠENIE: Semaphore ako ochrana
private static final Semaphore DB_LIMITER = new Semaphore(50);

public Order getOrder(Long id) {
    DB_LIMITER.acquire();
    try {
        return orderRepository.findById(id).orElseThrow();
    } finally {
        DB_LIMITER.release();
    }
}

// ❌ PROBLÉM: ThreadLocal s miliónom virtual threadov = memory leak
private static final ThreadLocal<ExpensiveObject> TL =
    ThreadLocal.withInitial(ExpensiveObject::new);

// ✅ RIEŠENIE: Použiť ScopedValue (Java 21+)
private static final ScopedValue<RequestContext> CONTEXT = ScopedValue.newInstance();

// ❌ PROBLÉM: @PreAuthorize nefunguje s reaktívnymi typmi v parametroch
@PreAuthorize("hasRole('ADMIN')")
@GetMapping("/admin/users")
public Flux<UserDto> getUsers() {
    // Funguje — ale len pre jednoduché role-based kontroly
    return userService.getAllUsers();
}

// ❌ PROBLÉM: Komplexné expression-based kontroly
@PreAuthorize("@authService.canAccess(#id)")
@GetMapping("/orders/{id}")
public Mono<OrderDto> getOrder(@PathVariable Long id) {
    // authService.canAccess() musí vrátiť Mono<Boolean>?
    // Nie — @PreAuthorize očakáva synchronný boolean!
    // Musíte buď:
    // 1. Zavolať .block() v authService (anti-pattern)
    // 2. Prepísať security logiku do reaktívneho reťazca
    return orderService.getOrder(id);
}

// Workaround: Security logika priamo v reaktívnom reťazci
@GetMapping("/orders/{id}")
public Mono<OrderDto> getOrder(@PathVariable Long id) {
    return ReactiveSecurityContextHolder.getContext()
        .map(ctx -> ctx.getAuthentication())
        .flatMap(auth -> {
            // Manuálna autorizácia v reaktívnom reťazci
            if (!authService.canAccessOrder(auth, id)) {
                return Mono.error(new AccessDeniedException("Forbidden"));
            }
            return orderService.getOrder(id);
        });
}

// ✅ Virtual Threads: @PreAuthorize funguje normálne
@PreAuthorize("@authService.canAccess(#id)")
@GetMapping("/orders/{id}")
public OrderDto getOrder(@PathVariable Long id) {
    return orderService.getOrder(id);
    // authService.canAccess() je synchronná metóda
    // Všetko funguje out-of-the-box
}

// ❌ PROBLÉM: SecurityContext sa stratí pri novom Mono
@GetMapping("/orders/{id}")
public Mono<OrderDto> getOrder(@PathVariable Long id) {
    return orderService.getOrder(id)
        .flatMap(order -> {
            // Chceme enrichnúť order dátami z iného servisu
            // Vytvoríme nový Mono — a SecurityContext je preč!
            Mono<EnrichmentData> enrichment = enrichmentService.enrich(order);

            return enrichment.map(data -> {
                // Tu už ReactiveSecurityContextHolder.getContext()
                // vráti EMPTY — autentifikácia sa stratila
                return OrderDto.from(order, data);
            });
        });
}

// ❌ PROBLÉM: Scheduler prepne vlákno, context sa nepropaguje
@GetMapping("/report")
public Mono<ReportDto> getReport() {
    return ReactiveSecurityContextHolder.getContext()
        .flatMap(ctx -> {
            String username = ctx.getAuthentication().getName();
            return reportService.generate(username);
        })
        .subscribeOn(Schedulers.boundedElastic());
        // ^ Scheduler prepne na iné vlákno
        // SecurityContext sa nepreniesol!
}

// ✅ WORKAROUND: Manuálna propagácia cez Reactor Context
@GetMapping("/orders/{id}")
public Mono<OrderDto> getOrder(@PathVariable Long id) {
    return ReactiveSecurityContextHolder.getContext()
        .flatMap(securityContext -> {
            Authentication auth = securityContext.getAuthentication();
            // Explicitne preniesť auth do každého sub-reťazca
            return orderService.getOrder(id)
                .flatMap(order -> enrichmentService.enrich(order, auth)
                    .map(data -> OrderDto.from(order, data))
                );
        });
}

// ✅ Virtual Threads: SecurityContext je vždy dostupný
@GetMapping("/orders/{id}")
public OrderDto getOrder(@PathVariable Long id) {
    // SecurityContextHolder.getContext() funguje kdekoľvek
    Order order = orderService.getOrder(id);
    EnrichmentData data = enrichmentService.enrich(order);
    return OrderDto.from(order, data);
    // Žiadne manuálne prenášanie kontextu
}

// ❌ PROBLÉM: Volanie blocking kódu v WebFlux
@GetMapping("/report")
public Mono<ReportDto> generateReport() {
    return Mono.fromCallable(() -> {
        // Toto blokuje event loop thread!
        byte[] pdf = pdfGenerator.generate();  // blocking I/O
        String url = s3Client.upload(pdf);      // blocking I/O
        return new ReportDto(url);
    }).subscribeOn(Schedulers.boundedElastic()); // ← Nutný workaround
}

// Virtual Threads: Normálny test
@Test
void shouldGetOrder() {
    Order order = orderService.getOrder(1L);
    assertEquals("Pizza", order.getName());
}

// WebFlux: StepVerifier ceremony
@Test
void shouldGetOrder() {
    StepVerifier.create(orderService.getOrder(1L))
        .assertNext(order -> assertEquals("Pizza", order.getName()))
        .verifyComplete();
}

// ❌ PROBLÉM: @Scheduled je synchronný, ale vaše servisy vracajú Mono
@Scheduled(fixedRate = 60_000)
public void cleanupExpiredSessions() {
    // sessionService vracia Mono — ale @Scheduled je synchronný!

    // Varianta A: .block() — anti-pattern, ale funguje
    sessionService.deleteExpired().block();

    // Varianta B: .subscribe() — chyby sa ticho prehltia!
    sessionService.deleteExpired().subscribe();
    // Ak deleteExpired() zlyhá, nikto sa nedozvie...
}

// ❌ PROBLÉM: Scheduled task nemá žiadny SecurityContext
@Scheduled(cron = "0 0 2 * * *")
public void generateDailyReport() {
    // ReactiveSecurityContextHolder.getContext() → EMPTY
    // Kto ste? Neviem. Nemáte autentifikáciu.
    reportService.generateAsAdmin().block(); // Kto je "admin"?
}

// ❌ PROBLÉM: .subscribe() nečaká na dokončenie
@Scheduled(fixedRate = 30_000)
public void syncInventory() {
    inventoryService.syncAll()
        .subscribe(
            result -> log.info("Synced: {}", result),
            error -> log.error("Sync failed", error)  // Ľahko zabudnúť
        );
    // Metóda skončí HNEĎ — nečaká na výsledok
    // Ak nasledujúci tick príde skôr než dobehne predošlý → chaos
}

// ✅ Virtual Threads: Klasický @Scheduled, žiadne problémy
@Scheduled(fixedRate = 60_000)
public void cleanupExpiredSessions() {
    sessionService.deleteExpired(); // Synchronné, blocking, funguje
}

@Scheduled(cron = "0 0 2 * * *")
public void generateDailyReport() {
    // Nastavíme systémovú identitu pre scheduled tasky
    SecurityContextHolder.getContext()
        .setAuthentication(systemAuthentication);
    reportService.generateAsAdmin(); // Funguje, čaká na výsledok
}