Spring WebFlux .doOnSubscribe & .doFinally. Is this race condition possible, if so, how to fix it?

by

Summary

The question revolves around the potential race condition in the provided Spring WebFlux code, specifically between the .doOnSubscribe and .doFinally methods. The concern is whether it’s possible for .doFinally to execute before .doOnSubscribe, leading to a situation where a subscription instance is not properly removed from the SUBSCRIPTIONS map.

Root Cause

The root cause of this potential issue lies in the asynchronous nature of the WebFlux framework and the way subscriptions are handled. When a client obtains a connection and then instantly disconnects, it can lead to a race condition between the subscription setup and teardown processes. The key factors contributing to this issue are:

  • The use of asynchronous operations in WebFlux
  • The non-deterministic order of execution for .doOnSubscribe and .doFinally
  • The shared state of the SUBSCRIPTIONS map

Why This Happens in Real Systems

This issue can occur in real systems due to the following reasons:

  • Concurrent connections: Multiple clients connecting and disconnecting simultaneously can increase the likelihood of a race condition
  • Network latency: Variations in network latency can affect the order of events, making it more likely for .doFinally to execute before .doOnSubscribe
  • System load: High system load can lead to delays in processing, increasing the chance of a race condition

Real-World Impact

The potential impact of this issue includes:

  • Subscription leaks: Failure to remove subscription instances from the SUBSCRIPTIONS map can lead to memory leaks and other performance issues
  • Incorrect state: Inconsistent state due to the race condition can cause errors and unexpected behavior in the application
  • Difficulty in debugging: The non-deterministic nature of the issue can make it challenging to reproduce and debug

Example or Code

// Example of using doOnSubscribe and doFinally with WebFlux
Flux<ServerSentEvent> flux = sink.asFlux()
        .doOnSubscribe(sub -> {
            // Subscription setup code
            SUBSCRIPTIONS.put(id, sub);
        })
        .doFinally(type -> {
            // Subscription teardown code
            SUBSCRIPTIONS.remove(id);
            sub.sink.tryEmitComplete();
        });

How Senior Engineers Fix It

To fix this issue, senior engineers can employ the following strategies:

  • Use synchronized blocks: Synchronize access to the SUBSCRIPTIONS map to prevent concurrent modifications
  • Implement a lock: Use a lock to ensure that only one thread can execute the subscription setup and teardown code at a time
  • Use atomic operations: Utilize atomic operations to update the SUBSCRIPTIONS map, ensuring that the subscription instance is properly removed
  • Review and refactor code: Carefully review the code and refactor it to avoid shared state and minimize the likelihood of a race condition

Why Juniors Miss It

Junior engineers may miss this issue due to:

  • Lack of experience: Limited experience with asynchronous programming and concurrent systems can make it difficult to anticipate and identify potential race conditions
  • Insufficient knowledge: Inadequate understanding of the WebFlux framework and its asynchronous nature can lead to overlooking the potential for a race condition
  • Overlooking edge cases: Failure to consider edge cases, such as a client instantly disconnecting, can result in missing this potential issue
  • Inadequate testing: Insufficient testing and simulation of various scenarios can make it challenging to detect and diagnose the problem

Leave a Comment