`RedisCache` does not comply with non-blocking semantics for `evict` and `clear` methods

[cgual-omnidian]

I noticed this issue when using Spring Boot Webflux (v3.4.10), Spring Framework (v6.2.11) and Spring Data Redis (v3.4.10).
Our service is using a Redis cache with support provided by Lettuce (v6.4.2.RELEASE).

The service uses the @Cacheable and @CacheEvict annotations with reactive support:

    @Cacheable(RedisCacheConfig.IDs.ATTRIBUTES_CACHE)
    fun getAttributes(id: Identifier): Mono<List<Attribute>> =
        attributesService.getAttributesById(id)
           
    @CacheEvict(RedisCacheConfig.IDs.ATTRIBUTES_CACHE)
    fun evictAttributes(id: Identifier): Mono<Unit> = Mono.empty()

Calling code was evicting some keys if they happened to return an empty list:

   idList.associateWith { id ->
      attributesCache.getAttributes(id)
          .flatMap { attributes ->
                    // evict cached attributes from redis if the attributes list is empty
                    if (attributes.isEmpty()) {
                        attributesCache
                            .evictRelevantAssetAttributes(id)
                            .then(Mono.just(attributes))
                    } else {
                        Mono.just(attributes)
                    }
          }
          .awaitSingle()
   }

We underestimated the number of times that we would be evicting cache entries and the service eventually became unresponsive and started logging errors due to 1 minute cache command timeouts (for get, store & evictions).

Digging into the problem we noticed that the number of blocking JVM threads spiked during this time. Using a debugger it is possible to trace the eviction flow and it looks like there is a blocking operation going on during cache eviction.

The Spring Framework is interacting through Spring Data Redis via the Cache interface which notes in the JavaDocs for the evict method:

If the cache is supposed to be compatible with CompletableFuture and reactive interactions, the evict operation needs to be effectively non-blocking, with any backend write-through happening asynchronously.

It looks like using Spring Data Redis with Lettuce supports async/reactive retrieve & store operations via the AsynchronousCacheWriterDelegate class.

However, it also looks like calls to evict a key use the synchronous cache writer via the DefaultRedisCacheWriter which blocks when invoking the del command via LettuceKeyCommands in LettuceConnection.

Is there a version / configuration of Spring Data Redis that supports async cache evictions? or is that functionality missing?

[mp911de]

Thanks for reaching out. RedisCache.evict(…) and clear() methods do not adhere to the non-blocking contract which we consider a bug that we want to fix.
With this fix we would add proper support for invalidate() and evictIfPresent(…) methods.