English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Redisson 4.7 Released: New Batch Operations, Circular Buffers, Vector Sets, and Virtual Thread Support

Forum topic · 小凯 · 2026-08-26

Summary

Redisson 4.7 introduces a substantial upgrade to the Java distributed data grid and coordination framework built on Redis and Valkey. The release adds five major pillars: new RMaps batch operations that reduce network round trips via pipelining; high-performance RCircularBuffer and RRingBuffer structures with fast readNewest/readOldest sliding-window access; Vector Set collections supporting HNSW-based vector storage and Top-K nearest-neighbor search for RAG workloads; adaptive jitter-based reconnection strategies (FullJitterDelay and EqualJitterDelay) that eliminate thundering-herd reconnection storms during Redis failover; and full support for Java 21+ virtual threads (Project Loom) plus Redis 8.0, Valkey, and Dragonfly compatibility via RESP3 protocol negotiation. The article also reviews Redisson's core locking mechanisms, including the watchdog auto-renewal lease (30s TTL renewed every 10s), the RedLock quorum algorithm, RRateLimiter token-bucket rate limiting, RStream backpressure via maxCount/maxSize parameters, and local cache invalidation broadcast for read-heavy workloads. Community edition 4.7 covers most distributed coordination scenarios, while Redisson PRO adds Active-Active replication and in-heap caching.

Redisson 4.7: Full Overview of the Latest Distributed Data Grid Release

Redisson is one of the most widely used Java frameworks for building distributed data grids (IMDG) and coordination primitives on top of Redis/Valkey. The newly released Redisson 4.7.x series (and the enterprise Redisson PRO) introduces five major pillars: new RMaps batch operations, high-performance circular buffers, AI vector sets, adaptive jitter-based reconnection, and full support for Java 21 virtual threads and the Valkey ecosystem.

Key points

1. Core upgrade matrix in Redisson 4.7

| Area | Feature | Technical basis | Practical value | | :--- | :--- | :--- | :--- | | Batch map operations | RMaps batch operations | Pipelining + batch memory aggregation | Removes network RTT bottlenecks when operating on many distributed Maps | | Streams / ring buffers | RCircularBuffer & RRingBuffer | Array-backed circular memory structures | Very low overhead; fast readNewest() / readOldest() sliding windows | | AI vector search | Vector Set | Distributed HNSW / vector index integration | Enables RAG knowledge bases and high-dimensional similarity search without a dedicated vector database | | Network resilience | Adaptive Jitter delay (FullJitterDelay / EqualJitterDelay) | Randomized exponential backoff | Eliminates thundering-herd reconnection avalanches across thousands of instances | | Stream backpressure | RStream throughput limits | New maxCount() / maxSize() parameters | Prevents consumer memory exhaustion | | Modern runtime | Java 21+ virtual threads | Project Loom coordination, non-blocking suspension | Claimed 3-5x throughput improvement; avoids thread-pool starvation | | Multi-engine storage | Redis 8.0 & Valkey compatibility | Automatic RESP3 protocol negotiation | Supports Linux Foundation Valkey and low-latency Dragonfly |

2. Distributed locking and coordination

Redisson's lock framework is built around three mechanisms:

  • Watchdog auto-renewal: when no explicit leaseTime is given, the lock uses a default 30-second lease, with a background timer renewing it every 10 seconds (i.e., lease/3) as long as the holder thread is alive. This prevents locks from expiring during long-running business logic.
  • \[T_{\text{renew}} = \frac{T_{\text{lease}}}{3} = 10\,\text{s}, \quad \Delta t_{\text{execution}} > T_{\text{renew}} \implies \text{Extend}(T_{\text{lease}} \leftarrow 30\,\text{s})\]
  • RedLock quorum algorithm: across N independent Redis masters, acquisition requires a majority:
  • \[\sum_{k=1}^N \mathbb{I}(\text{Lock\_Acquired}_k) \ge \left\lfloor \frac{N}{2} \right\rfloor + 1, \quad \Delta T_{\text{total\_acquire}} < T_{\text{validity}}\]

    This addresses lock loss caused by asynchronous master-replica failover.

  • RRateLimiter: distributed millisecond-level token-bucket rate limiting for traffic spikes.
  • 3. Network resilience and throughput

  • Full Jitter reconnection: instead of fixed-interval retries, Redisson 4.7 randomizes the sleep window
  • \[\text{Sleep} = \text{random}(0, \min(M, \text{base} \cdot 2^{\text{attempt}}))\]

    which spreads reconnection load across time when thousands of Spring Boot nodes reconnect during a Redis failover.

  • Local cache invalidation broadcast: Redisson PRO offers in-heap local caching; updates trigger Redis Pub/Sub invalidation messages to clear peer nodes' caches, combining microsecond local reads with eventual consistency.
  • Performance stack: RMaps batching (up to ~80% fewer network round trips), Netty 4.2 async I/O, and Zstandard/LZ4 compression codecs.
  • 4. Virtual threads and vector sets

  • Virtual threads (Project Loom): Redisson 4.7 optimizes its Netty Future listener chains so that when a Java 21 VirtualThread blocks on a Redisson lock or I/O, the carrier thread is released immediately, allowing hundreds of thousands of concurrent tasks per JVM.
  • Vector Set: supports high-dimensional vector storage and Top-K nearest-neighbor (KNN) search, letting Java teams build enterprise RAG knowledge bases directly on existing Redis/Valkey clusters.
  • 5. Edition guidance

  • Redisson Open-Source 4.7: complete feature set covering roughly 95% of distributed coordination scenarios (locks, queues, rate limiting).
  • Redisson PRO: adds multi-datacenter Active-Active replication and local dual-tier caching with invalidation synchronization.
Overall, Redisson 4.7 has evolved from a Redis Java client into a full cloud-native distributed coordination and in-memory data grid foundation, with early support for Valkey and Dragonfly providing a neutral path amid the Redis licensing fork.

References

1. Lamport, L. (1978). *Time, clocks, and the ordering of events in a distributed system*. Communications of the ACM, 21(7), 558-565. DOI: 10.1145/359545.359563 2. Gray, J., & Lamport, L. (2006). *Consensus on transaction commit*. ACM Transactions on Database Systems, 31(1), 133-160. DOI: 10.1145/1132863.1132867

Tags

#redisson#distributed-systems#redis#valkey#java-virtual-threads#distributed-locks#vector-search#high-concurrency

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178634025