BestHub
Sign in
Tagged articles

redisson

173 articles · Page 1 of 2
Java Architect Handbook
Java Architect Handbook
Jul 4, 2026 · Backend Development

How to Build a Clean SpringBoot Scaffold Quickly

The article walks through creating a SpringBoot project from scratch, covering IDE setup pain points, project initialization, version compatibility between SpringBoot, Spring Cloud and Kafka, Maven dependency management, core scaffold classes such as global exception handling, logging aspect, CORS and Swagger configuration, and recommends useful tools like embedded Redis, MariaDB, Hutool, MyBatis‑Plus, MapStruct and Redisson.

embedded-rediskafkamapstruct
0 likes · 11 min read
How to Build a Clean SpringBoot Scaffold Quickly
Java Tech Workshop
Java Tech Workshop
Jun 2, 2026 · Backend Development

Implementing Distributed Locks in Spring Boot with Redis

This article explains why local locks like synchronized and ReentrantLock fail in microservice clusters, introduces the fundamentals and essential properties of distributed locks, walks through five iterative Redis lock implementations that address dead‑lock, atomicity, and timeout issues, and finally shows how to adopt the production‑grade Redisson library with best‑practice guidelines for key naming, lock scope, and lock type selection.

Distributed LockJavaMicroservices
0 likes · 17 min read
Implementing Distributed Locks in Spring Boot with Redis
ITPUB
ITPUB
May 26, 2026 · Backend Development

Why Using Redis Expiration Listener for Order Cancellation Is a Bad Idea

The article compares common delayed‑task solutions for order cancellation, explains why Redis expiration listeners, RabbitMQ dead‑letter queues, and in‑memory time wheels are unreliable, and recommends using proper message‑queue delayed delivery or Redisson delay queues with compensation mechanisms.

DelayQueueDelayed TasksMessage Queue
0 likes · 7 min read
Why Using Redis Expiration Listener for Order Cancellation Is a Bad Idea
Linyb Geek Road
Linyb Geek Road
May 14, 2026 · Backend Development

How to Build a Reliable 15‑Minute Order Auto‑Cancel in Java: From Naïve @Scheduled to Production‑Ready Redisson

The article walks through the pitfalls of a seemingly simple 15‑minute unpaid‑order cancellation requirement, evaluates five implementation options—from a basic @Scheduled poll to Redis ZSet, DelayQueue, and distributed Redisson solutions—culminating in a production‑grade Redisson scheduler with optimistic‑lock safeguards and detailed best‑practice guidelines.

JavaOrder TimeoutRedis
0 likes · 13 min read
How to Build a Reliable 15‑Minute Order Auto‑Cancel in Java: From Naïve @Scheduled to Production‑Ready Redisson
Architect's Guide
Architect's Guide
Apr 18, 2026 · Databases

How to Import 1 Billion Records into MySQL at Lightning Speed

This article analyzes the constraints of loading a billion 1‑KB log records from HDFS/S3 into MySQL, evaluates single‑table limits, proposes batch inserts, sharding, file‑reading techniques, task coordination with Redis, Redisson, and Zookeeper, and offers practical performance‑tuning recommendations.

Bulk InsertPerformance TuningRedis
0 likes · 21 min read
How to Import 1 Billion Records into MySQL at Lightning Speed
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 19, 2026 · Backend Development

How to Ensure Single-Node Execution of Spring Boot @Scheduled Tasks in Distributed Environments

This guide explains why @Scheduled jobs run on every Spring Boot instance in a cluster, and presents three practical solutions—Spring Integration's Redis lock, Redisson, and ShedLock—complete with Maven dependencies, configuration snippets, code examples, and runtime screenshots to guarantee that only one node executes the scheduled task at a time.

Backend DevelopmentDistributed LockRedis
0 likes · 9 min read
How to Ensure Single-Node Execution of Spring Boot @Scheduled Tasks in Distributed Environments
ITPUB
ITPUB
Jan 7, 2026 · Backend Development

Step‑by‑Step Guide to Upgrade Spring Boot 3.x to 4.0 Without Pain

This guide walks through upgrading a Spring Boot 3.x project to 4.0, covering Gradle version bump, dependency version catalog updates, modular starter changes, the breaking Jackson 3 package rename, Redisson API adjustments, verification steps, and best‑practice upgrade path to avoid common pitfalls.

gradlejackson-3redisson
0 likes · 12 min read
Step‑by‑Step Guide to Upgrade Spring Boot 3.x to 4.0 Without Pain
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Dec 23, 2025 · Backend Development

Mastering Redis Distributed Locks: From SETNX to RedLock and WatchDog

This article walks through the evolution of Redis distributed locks—from basic SETNX mutual exclusion to atomic SET with expiration, Lua‑based safe unlocking, Redisson's WatchDog auto‑renewal, and the RedLock algorithm—highlighting pitfalls, best‑practice implementations, and interview‑style Q&A for robust production use.

Distributed LockJavaRedis
0 likes · 15 min read
Mastering Redis Distributed Locks: From SETNX to RedLock and WatchDog
Tech Freedom Circle
Tech Freedom Circle
Dec 12, 2025 · Backend Development

Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement

The article explains how Redisson implements a re‑entrant distributed lock using Redis hash structures and the atomic HINCRBY command to manage client identity, re‑entry counting, concurrency safety, and graceful release, providing a complete technical analysis with code, Lua scripts, and best‑practice guidelines.

Distributed LockHINCRBYJava
0 likes · 34 min read
Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement
Java Baker
Java Baker
Oct 27, 2025 · Backend Development

Master Java Rate Limiting: Guava, Sentinel, and Redisson Solutions

This article compares three Java rate‑limiting approaches—Guava RateLimiter for single‑node control, Sentinel for both single‑node and cluster scenarios, and Redisson RateLimiter for distributed limits—detailing their usage, advantages, disadvantages, and code examples to help developers choose the right solution for their traffic management needs.

GuavaJavaSentinel
0 likes · 12 min read
Master Java Rate Limiting: Guava, Sentinel, and Redisson Solutions
Cognitive Technology Team
Cognitive Technology Team
Sep 25, 2025 · Backend Development

How to Accurately Count Valid Entries in Redisson RMapCache

This article explains why Redisson's RMapCache.size() includes expired entries, demonstrates how to obtain the exact number of currently valid key‑value pairs using keySet().size() or readAllEntrySet().size(), and provides performance tips and a real‑world e‑commerce use case.

Cache MonitoringJavaRMapCache
0 likes · 10 min read
How to Accurately Count Valid Entries in Redisson RMapCache
Code Ape Tech Column
Code Ape Tech Column
Jul 24, 2025 · Backend Development

Mastering Redisson Distributed Locks: Deep Dive into Implementation, Reentrancy, and Fairness

This article provides a comprehensive guide to Redisson's distributed lock implementation, covering its architecture, comparison with Jedis and Lettuce, basic lock creation, Lua scripts for atomic operations, reentrant lock handling, watchdog-based lock renewal, RLock usage, and the design of fair locks using Redis data structures.

Distributed LockRedisfair lock
0 likes · 31 min read
Mastering Redisson Distributed Locks: Deep Dive into Implementation, Reentrancy, and Fairness
Lin is Dream
Lin is Dream
Jul 8, 2025 · Databases

How Bloom Filters Supercharge Redis: From BitSet to Redisson

This article explains the Bloom filter data structure, its hash‑based design and false‑positive behavior, then demonstrates practical implementations using Java BitSet, Guava, and Redisson, covering initialization, configuration, usage tips, and performance considerations for Redis bitmap storage.

BitsetData StructuresGuava
0 likes · 13 min read
How Bloom Filters Supercharge Redis: From BitSet to Redisson
Lin is Dream
Lin is Dream
Jul 2, 2025 · Databases

Master Redis in Spring Boot: From RedisTemplate to Redisson Integration

This tutorial walks Java developers through using Redis in Spring Boot projects, covering the essential spring-boot-starter-data-redis dependency, RedisTemplate basics, the underlying RedisConnectionFactory design, custom connection configurations for single‑node and sentinel modes, and seamless integration of the Redisson client for advanced distributed features.

JavaRedisRedisTemplate
0 likes · 10 min read
Master Redis in Spring Boot: From RedisTemplate to Redisson Integration
Architect's Must-Have
Architect's Must-Have
Jun 6, 2025 · Backend Development

Why Simple synchronized Locks Fail in Distributed Systems and How Redisson Fixes Them

This article examines common pitfalls of using single‑machine synchronization and basic SETNX locks for high‑concurrency stock‑deduction scenarios, demonstrates step‑by‑step improvements—including lock expiration and Redisson’s Lua‑based implementation—and discusses trade‑offs between Redis and Zookeeper for distributed locking.

Redisdistributed-lockredisson
0 likes · 16 min read
Why Simple synchronized Locks Fail in Distributed Systems and How Redisson Fixes Them
Zhuanzhuan Tech
Zhuanzhuan Tech
Jun 4, 2025 · Backend Development

A Comprehensive Guide to Redisson Distributed Locks in Java

This article explains Redisson's various distributed lock mechanisms—including watchdog, reentrant lock, multi‑lock, read‑write lock, semaphore, RedLock, and CountDownLatch—detailing their principles, usage patterns, code examples, and best‑practice recommendations for robust backend concurrency control.

Distributed LocksJavaRedis
0 likes · 16 min read
A Comprehensive Guide to Redisson Distributed Locks in Java
Java Tech Enthusiast
Java Tech Enthusiast
May 17, 2025 · Backend Development

How to Implement Distributed API Debounce in Java with Redis and Redisson

This article explains why API debounce is needed in web back‑ends, identifies the types of endpoints that require it, outlines how to detect duplicate requests, and provides two concrete distributed solutions—shared Redis cache and Redisson lock—complete with annotation design, key generation logic, and full Java code examples.

API DebounceDistributed LockJava
0 likes · 15 min read
How to Implement Distributed API Debounce in Java with Redis and Redisson
Java Captain
Java Captain
May 9, 2025 · Backend Development

Implementing Precise Order Cancellation: Delayed Task Solutions and Their Pitfalls

The article examines various approaches for implementing accurate order‑cancellation timers in e‑commerce systems, compares message‑queue delayed delivery, Redisson delay queues, Redis expiration listeners, RabbitMQ dead‑letter queues, and time wheels, and recommends reliable solutions while warning against common pitfalls.

Backend DevelopmentDelayed TasksTime Wheel
0 likes · 8 min read
Implementing Precise Order Cancellation: Delayed Task Solutions and Their Pitfalls
Java Architect Essentials
Java Architect Essentials
Apr 25, 2025 · Backend Development

Precise Order‑Closing Delayed Tasks: Best Practices and Common Pitfalls

This article compares several ways to implement order‑closing delayed tasks—message‑queue delayed delivery, Redisson DelayQueue, Redis expiration listening, RabbitMQ dead‑letter queues, and time wheels—explaining their mechanisms, drawbacks, and recommending the most reliable solutions for production systems.

Delayed TasksMessage QueueRabbitMQ
0 likes · 7 min read
Precise Order‑Closing Delayed Tasks: Best Practices and Common Pitfalls
Selected Java Interview Questions
Selected Java Interview Questions
Apr 4, 2025 · Backend Development

Guide to Using Lock4j Distributed Lock Component in Spring Boot

This article introduces the Lock4j distributed lock library, explains its features, shows how to add Maven dependencies, configure Redis, use the @Lock4j annotation for simple and advanced locking scenarios, and provides custom executor, key builder, and failure‑strategy examples for Spring Boot applications.

Distributed LockLock4jRedis
0 likes · 6 min read
Guide to Using Lock4j Distributed Lock Component in Spring Boot
Selected Java Interview Questions
Selected Java Interview Questions
Mar 30, 2025 · Backend Development

Implementing Precise Order Cancellation: Pitfalls of Redis Expiration and Better Alternatives

The article explains why using Redis expiration or RabbitMQ dead‑letter queues for delayed order‑cancellation tasks is unreliable, compares several approaches such as message‑queue delayed delivery, Redisson delay queues, and time wheels, and recommends robust solutions like RocketMQ or Pulsar for accurate timing.

Delayed TasksMessage QueueRabbitMQ
0 likes · 7 min read
Implementing Precise Order Cancellation: Pitfalls of Redis Expiration and Better Alternatives
Java Backend Full-Stack
Java Backend Full-Stack
Mar 17, 2025 · Fundamentals

How Redis Implements Bloom Filters to Prevent Cache Penetration

The article explains the probabilistic Bloom filter data structure, its initialization, hash‑based insertion and query process, illustrates collisions with concrete examples, and shows how Redis (via Redisson) supports Bloom filters with Java code to efficiently block cache‑penetration attacks.

Cache Penetrationbloom filterprobabilistic data structure
0 likes · 6 min read
How Redis Implements Bloom Filters to Prevent Cache Penetration
Architect
Architect
Dec 22, 2024 · Backend Development

Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)

This article explains the concept of request debouncing, identifies which API endpoints need it, and provides a detailed tutorial on implementing distributed debounce using shared Redis cache or Redisson locks in a Spring Boot backend, complete with annotation design, unique key generation, and code examples.

JavaRedisdebounce
0 likes · 16 min read
Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 18, 2024 · Fundamentals

Understanding Bloom Filters and Their Support in Redis

This article explains the probabilistic Bloom filter data structure, its characteristics and typical use cases such as cache‑penetration prevention, details its simple implementation steps, demonstrates how Redis (via Redisson) provides built‑in Bloom filter support with Java code examples, and summarizes its practical benefits.

Cache PenetrationJavaRedis
0 likes · 7 min read
Understanding Bloom Filters and Their Support in Redis
vivo Internet Technology
vivo Internet Technology
Nov 27, 2024 · Backend Development

Implementation Principles of Distributed Locks with Redis and Zookeeper

Distributed locks synchronize multiple services across nodes, and can be implemented using Redis’s fast, AP‑oriented SET‑NX with automatic TTL renewal or Zookeeper’s CP‑oriented ephemeral sequential nodes, each offering distinct trade‑offs in performance, consistency, and suitability for various workload requirements.

CAP theoremDistributed LockJava
0 likes · 24 min read
Implementation Principles of Distributed Locks with Redis and Zookeeper
Architect
Architect
Nov 10, 2024 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks

This article explains why API debouncing is crucial for backend Java services, outlines which endpoints need protection, describes how to identify duplicate requests, and provides step‑by‑step implementations using Redis shared‑cache and Redisson distributed locks with concrete code examples and test results.

Distributed LockJavaRedis
0 likes · 14 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks
Architect's Guide
Architect's Guide
Oct 31, 2024 · Databases

Designing an Efficient Pipeline for Importing One Billion Records into MySQL

This article presents a comprehensive engineering guide for importing one billion 1 KB unstructured log records stored in HDFS or S3 into MySQL, covering data sizing, B‑tree limits, batch insertion strategies, storage‑engine choices, sharding, file‑reading techniques, concurrency control, and reliable task coordination using Redis, Redisson, and Zookeeper.

Batch InsertPerformance OptimizationRedis
0 likes · 17 min read
Designing an Efficient Pipeline for Importing One Billion Records into MySQL
Architect
Architect
Sep 9, 2024 · Backend Development

Understanding Redisson DelayedQueue: Internal Mechanisms and Practical Usage

This article explains how Redisson's DelayedQueue works internally, covering its data structures, the basic workflow for sending and receiving delayed messages, the initialization process, and the scheduling logic that moves expired items from the delay queue to the target queue.

DelayedQueueJavaMessage Queue
0 likes · 16 min read
Understanding Redisson DelayedQueue: Internal Mechanisms and Practical Usage
Architect's Guide
Architect's Guide
Sep 5, 2024 · Databases

Strategies for Fast Import of 1 Billion Records into MySQL

To import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, the article examines data partitioning, B‑tree index limits, batch insertion, storage engine choices, concurrency control, file‑reading methods, task scheduling with Redis, Redisson, and Zookeeper for reliable, ordered, high‑throughput loading.

Batch InsertData PartitioningRedis
0 likes · 18 min read
Strategies for Fast Import of 1 Billion Records into MySQL
Code Ape Tech Column
Code Ape Tech Column
Aug 29, 2024 · Backend Development

Implementing Interface Debounce with Redis and Redisson in Java Backend

This article explains how to prevent duplicate submissions in Java backend APIs by applying debounce techniques using shared Redis caches or Redisson distributed locks, detailing the design of a @RequestLock annotation, key generation, aspect implementation, and practical testing results.

debouncedistributed-lockredisson
0 likes · 15 min read
Implementing Interface Debounce with Redis and Redisson in Java Backend
Java Backend Technology
Java Backend Technology
Aug 23, 2024 · Backend Development

How to Implement Distributed API Debounce with Redis and Redisson in Java

This article explains why API debounce is essential, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson lock—along with complete Java code examples and deployment tips for preventing duplicate submissions in a Spring Boot backend.

API idempotencyDistributed LockJava
0 likes · 16 min read
How to Implement Distributed API Debounce with Redis and Redisson in Java
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 24, 2024 · Backend Development

11 Ways to Implement Delayed Tasks – 16k Words, 28 Diagrams

This article surveys eleven Java‑based delayed‑task solutions—including DelayQueue, Timer, ScheduledThreadPoolExecutor, RocketMQ, RabbitMQ, Redis key‑expiration, Redisson, Netty’s HashedWheelTimer, Hutool SystemTimer, Quartz, and a simple polling loop—providing code demos, implementation principles, and practical pros and cons for each approach.

DelayQueueQuartzRabbitMQ
0 likes · 25 min read
11 Ways to Implement Delayed Tasks – 16k Words, 28 Diagrams
IT Architects Alliance
IT Architects Alliance
Jul 10, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Basic SETNX to RedLock and Redisson

This article explains how to implement distributed locks using Redis, starting with a simple SETNX approach, identifying its shortcomings, and then presenting solutions such as thread‑identifiers, Lua scripts for atomicity, handling TTL with watchdogs, the RedLock algorithm, and practical usage via the Redisson Java client.

Distributed LockJavaLua
0 likes · 18 min read
Mastering Distributed Locks with Redis: From Basic SETNX to RedLock and Redisson
Architect
Architect
Jul 9, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson

This article explains how to implement distributed locks using Redis, starting with a basic SETNX approach, identifying its shortcomings, and then presenting robust solutions such as identifier‑based unlocking, Lua scripts for atomicity, the RedLock algorithm, and Redisson’s advanced features including a watchdog mechanism.

Distributed LockJavaRedis
0 likes · 19 min read
Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson
Architecture Digest
Architecture Digest
Jun 25, 2024 · Backend Development

Implementing Request Debounce in Backend Systems Using Redis and Redisson

This article explains why request debouncing is essential for backend APIs, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson locks—along with complete Java annotation and aspect implementations, testing results, and best‑practice recommendations.

Annotationdebounceredisson
0 likes · 12 min read
Implementing Request Debounce in Backend Systems Using Redis and Redisson
Top Architect
Top Architect
Jun 5, 2024 · Backend Development

Implementing Interface Debounce (Anti‑duplicate Submission) in Java Backend with Redis and Redisson

This article explains how to prevent duplicate API calls in Java backend systems by using debounce techniques, shared Redis caches or Redisson distributed locks, and provides complete annotation‑based implementations with code examples, key generation strategies, and testing results to achieve idempotent interfaces.

Distributed LockJavaRedis
0 likes · 16 min read
Implementing Interface Debounce (Anti‑duplicate Submission) in Java Backend with Redis and Redisson
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 4, 2024 · Backend Development

Mastering Redisson Distributed Collections in Spring Boot 2.7

This article introduces Redisson as a Redis Java client and demonstrates how to use its distributed collection implementations—RMap, RSet, RList, RQueue, and various blocking queues—in Spring Boot 2.7, covering synchronous, fast, and asynchronous operations, lock binding, local caching, and event listeners.

Distributed CollectionsRedisSpring Boot
0 likes · 11 min read
Mastering Redisson Distributed Collections in Spring Boot 2.7
Programmer XiaoFu
Programmer XiaoFu
May 28, 2024 · Backend Development

SpringBoot Techniques for API Debounce to Eliminate Duplicate Submissions

The article explains why API debounce is essential, identifies the types of endpoints that need it, and walks through two SpringBoot solutions—Redis‑based shared cache and Redisson distributed lock—complete with custom annotations, key generation, code samples, test results, and practical limitations.

JavaRedisdebounce
0 likes · 14 min read
SpringBoot Techniques for API Debounce to Eliminate Duplicate Submissions
Lobster Programming
Lobster Programming
May 7, 2024 · Backend Development

How to Build Redis-Based Delayed Queues: 3 Practical Approaches

This article explains three common methods for implementing delayed queues with Redis—using key expiration notifications, Zset with scheduled tasks, and Redisson’s RDelayedQueue—detailing their concepts, core code examples, advantages, and limitations for backend developers.

Backend DevelopmentJavaRedis
0 likes · 5 min read
How to Build Redis-Based Delayed Queues: 3 Practical Approaches
IT Services Circle
IT Services Circle
Apr 25, 2024 · Backend Development

How Redisson Implements Distributed Locks Using Redis

This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.

DistributedLockJavaLua
0 likes · 19 min read
How Redisson Implements Distributed Locks Using Redis
vivo Internet Technology
vivo Internet Technology
Apr 10, 2024 · Databases

Analysis of Redis Pipeline Support in Spring Boot with Lettuce and Redisson Clients

The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.

JavaRedisSpring Boot
0 likes · 27 min read
Analysis of Redis Pipeline Support in Spring Boot with Lettuce and Redisson Clients
Architect
Architect
Feb 18, 2024 · Backend Development

How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls

This article explains why distributed locks are needed, outlines Redisson's lock properties, walks through its Lua‑based acquisition, renewal, and release processes, examines master‑slave pitfalls, compares RedLock with Zookeeper, and provides practical code examples for Java developers.

Distributed LockJavaLock Mechanism
0 likes · 14 min read
How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls
Selected Java Interview Questions
Selected Java Interview Questions
Feb 16, 2024 · Backend Development

Integrating Redis with Spring Boot: Dependencies, Configuration, and Usage Guide

This tutorial explains how to add Redis dependencies to a Spring Boot project, configure connection settings, use RedisTemplate for basic operations, enable Spring Cache, employ Redisson for distributed locks, and fine‑tune connection pool and timeout parameters, providing complete code examples.

Backend DevelopmentDistributed LockJava
0 likes · 10 min read
Integrating Redis with Spring Boot: Dependencies, Configuration, and Usage Guide
IT Niuke
IT Niuke
Feb 3, 2024 · Backend Development

A Powerful Distributed Lock Framework: Introducing Lock4j

This guide introduces Lock4j, a versatile distributed‑lock component for Java that works with Spring AOP and supports RedisTemplate, Redisson, and Zookeeper, and walks through its features, configuration, annotation attributes, basic usage, and advanced customization options.

Distributed LockJavaLock4j
0 likes · 7 min read
A Powerful Distributed Lock Framework: Introducing Lock4j
Code Ape Tech Column
Code Ape Tech Column
Jan 15, 2024 · Backend Development

Understanding the Internal Working of Redisson DelayedQueue

This article explains how Redisson's DelayedQueue implements a distributed delayed message queue, covering basic usage, internal data structures, the overall processing flow, and detailed code analysis of sending, receiving, and initializing delayed messages in Java.

DelayedQueueDistributedQueueJava
0 likes · 16 min read
Understanding the Internal Working of Redisson DelayedQueue
dbaplus Community
dbaplus Community
Dec 10, 2023 · Databases

How to Import 1 Billion Records into MySQL in Record Time

This article outlines a comprehensive strategy for rapidly loading one billion 1 KB log records stored in HDFS or S3 into MySQL, covering data partitioning, B‑tree limits, batch inserts, storage‑engine selection, sharding, concurrent write control, efficient file reading, task coordination, fault‑tolerant progress tracking with Redis, and distributed locking with Redisson.

Batch InsertDistributed LockFile Reading
0 likes · 20 min read
How to Import 1 Billion Records into MySQL in Record Time
MaGe Linux Operations
MaGe Linux Operations
Dec 7, 2023 · Backend Development

Mastering Redis: From Core Data Types to Enterprise‑Scale Distributed Locks

This comprehensive guide explains Redis fundamentals, its rich data structures, persistence mechanisms (RDB and AOF), enterprise‑level configuration strategies, common usage patterns such as caching, ranking and geolocation, and dives deep into distributed lock implementations with Redisson and Lua scripts, providing practical code examples for real‑world applications.

CachingDistributed LockLua
0 likes · 31 min read
Mastering Redis: From Core Data Types to Enterprise‑Scale Distributed Locks
Architect
Architect
Nov 28, 2023 · Databases

How to Import 1 Billion Records into MySQL Efficiently: Architecture & Performance Guide

This article walks through the full engineering process of importing a billion 1 KB log records into MySQL, covering data size calculations, B‑tree index limits, batch‑insert strategies, storage‑engine trade‑offs, fast file‑reading techniques, task coordination with Redis and Redisson, and distributed‑lock design using Zookeeper.

Batch InsertDistributed TasksPerformance Optimization
0 likes · 20 min read
How to Import 1 Billion Records into MySQL Efficiently: Architecture & Performance Guide
Architecture Digest
Architecture Digest
Nov 23, 2023 · Backend Development

Using Redisson Distributed Locks with Custom Annotations in Java

This article explains how to apply Redisson's distributed lock in Java, demonstrates the basic lock and tryLock APIs, shows how to create a custom @DistributedLock annotation and an AOP aspect to handle locking automatically, and provides a practical usage example with two services.

AOPAnnotationDistributed Lock
0 likes · 8 min read
Using Redisson Distributed Locks with Custom Annotations in Java
Java High-Performance Architecture
Java High-Performance Architecture
Oct 31, 2023 · Backend Development

Master Redisson Distributed Locks in Java: Features, Code & Spring Boot

This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.

Distributed LockJavaRedis
0 likes · 11 min read
Master Redisson Distributed Locks in Java: Features, Code & Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Oct 18, 2023 · Databases

Efficient Strategies for Importing One Billion Records into MySQL

This article explains how to import 1 billion 1 KB log records stored in HDFS or S3 into MySQL by analyzing table capacity limits, choosing storage engines, designing batch inserts, coordinating file reading and writing, and handling task reliability with Redis, Redisson, and Zookeeper.

Batch InsertDistributed TasksPerformance Optimization
0 likes · 18 min read
Efficient Strategies for Importing One Billion Records into MySQL
政采云技术
政采云技术
Oct 12, 2023 · Backend Development

Understanding Redisson Distributed Locks: Architecture, Code Walkthrough, and Watchdog Mechanism

This article introduces Redisson, a high‑performance Java Redis client built on Netty, explains its key advantages, and provides a detailed walkthrough of the RedissonLock implementation—including tryLock, blocking lock, unlock logic, associated Lua scripts, and the automatic watchdog renewal mechanism.

Distributed LockJavaNetty
0 likes · 12 min read
Understanding Redisson Distributed Locks: Architecture, Code Walkthrough, and Watchdog Mechanism
Java High-Performance Architecture
Java High-Performance Architecture
Sep 25, 2023 · Backend Development

Master Distributed Locks with Redisson: Deep Dive into Java High‑Performance Architecture

This article explains the concept of distributed locks for ensuring data consistency in clustered environments, outlines common implementation approaches, and provides a comprehensive guide to using Redisson in Java—including Maven setup, YAML configuration, core source‑code analysis, Lua scripts for lock and unlock operations, and practical test cases.

Distributed LockJavaLua
0 likes · 15 min read
Master Distributed Locks with Redisson: Deep Dive into Java High‑Performance Architecture
Top Architect
Top Architect
Sep 6, 2023 · Backend Development

Using Redisson for Distributed Locks in Java: Configuration, Code Samples, and Source‑Code Analysis

This article explains how distributed locks solve data‑consistency problems in clustered environments, introduces Redisson as a Redis‑based locking library, provides Maven and YAML configuration, shows Java code for Redisson setup and test cases, and analyses the underlying Lua scripts and source‑code mechanisms.

Distributed LockJavaLua Script
0 likes · 18 min read
Using Redisson for Distributed Locks in Java: Configuration, Code Samples, and Source‑Code Analysis
JD Cloud Developers
JD Cloud Developers
Aug 24, 2023 · Backend Development

Mastering Java Locks: From ReentrantLock to Distributed Redisson & Zookeeper

This article explains the fundamentals and practical usage of various Java locking mechanisms—including ReentrantLock, synchronized, ReentrantReadWriteLock, and the Atomic and Concurrent families—then explores distributed lock solutions such as Redisson’s multiple lock types and Zookeeper/Curator, comparing their performance, consistency, and suitability for different scenarios.

JavaLocksZookeeper
0 likes · 22 min read
Mastering Java Locks: From ReentrantLock to Distributed Redisson & Zookeeper
Selected Java Interview Questions
Selected Java Interview Questions
Aug 24, 2023 · Backend Development

Implementing Distributed Locks with Redis and Redisson

This article explains how to create Redis‑based distributed locks, discusses common pitfalls such as deadlocks and accidental deletions, and provides practical solutions including atomic expiration commands, Lua scripts, and a complete Redisson Java example for acquiring and releasing locks safely.

Distributed LockJavaRedis
0 likes · 5 min read
Implementing Distributed Locks with Redis and Redisson
Architect
Architect
Jul 20, 2023 · Backend Development

10 Hidden Pitfalls of Redis Distributed Locks and How to Avoid Them

This article dissects ten common traps when implementing Redis distributed locks—such as non‑atomic setnx/expire, missing expirations, lock release ordering, non‑re‑entrancy, master‑slave replication issues, and the Redlock algorithm—while providing concrete code examples and practical remedies.

Backend DevelopmentDistributed LockJava
0 likes · 14 min read
10 Hidden Pitfalls of Redis Distributed Locks and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Jul 13, 2023 · Backend Development

Distributed Rate Limiting in Java: Fixed, Sliding, Leaky & Token Bucket

This article explains why rate limiting is essential for distributed systems, compares it with circuit breaking and smoothing, outlines a generic limiting workflow, and provides complete Java implementations of four algorithms—fixed window, sliding window, leaky bucket, and token bucket—using Redis and Redisson.

JavaRedisrate limiting
0 likes · 18 min read
Distributed Rate Limiting in Java: Fixed, Sliding, Leaky & Token Bucket
Shepherd Advanced Notes
Shepherd Advanced Notes
Jun 27, 2023 · Backend Development

Implementing Distributed Locks in Spring Boot with Redisson

This article explains how Redisson extends Redis to provide a rich set of distributed Java objects and services, walks through integrating Redisson into a Spring Boot project, demonstrates various lock types (reentrant, read‑write, semaphore, latch) with code examples, and details the internal watchdog mechanism that guarantees atomic lock acquisition and automatic renewal.

Distributed LockJavaRedis
0 likes · 19 min read
Implementing Distributed Locks in Spring Boot with Redisson
Su San Talks Tech
Su San Talks Tech
Jun 26, 2023 · Backend Development

Mastering Bloom Filters: From Theory to Guava & Redisson Implementations

Explore the design and mechanics of Bloom filters, understand their role in preventing cache penetration, learn how to calculate optimal parameters, and see practical Java implementations using Google Guava and Redisson, including code snippets, performance considerations, and strategies for handling deletions.

Cache PenetrationData StructuresGuava
0 likes · 19 min read
Mastering Bloom Filters: From Theory to Guava & Redisson Implementations
Architect's Guide
Architect's Guide
Apr 30, 2023 · Backend Development

Evolution of Distributed Locks with Redis and Redisson

This article explains the step‑by‑step evolution of Redis‑based distributed lock implementations—from a simple SETNX approach to a robust solution using UUIDs, expiration, atomic Lua scripts, and finally Redisson’s high‑level lock API—illustrating common pitfalls and their fixes.

JavaRedisbackend
0 likes · 8 min read
Evolution of Distributed Locks with Redis and Redisson
Su San Talks Tech
Su San Talks Tech
Apr 15, 2023 · Fundamentals

Mastering Bloom Filters: Theory, Java Guava & Redisson Implementations

This article explores Bloom filters—how they efficiently test set membership, their underlying principles, error rates, and practical usage in Java via Guava and Redisson, including code examples, configuration tips, handling cache penetration, and strategies for element deletion and periodic rebuilding.

CacheData StructureGuava
0 likes · 18 min read
Mastering Bloom Filters: Theory, Java Guava & Redisson Implementations
Architect
Architect
Apr 4, 2023 · Backend Development

Evolution of Distributed Locks with Redis and Redisson

This article walks through the step‑by‑step evolution of Redis‑based distributed lock implementations—from simple SETNX locking to atomic expiration, UUID‑based ownership, Lua‑scripted safe release, and finally using Redisson’s high‑level lock API—illustrating common pitfalls and robust solutions.

Distributed LockJavaRedis
0 likes · 8 min read
Evolution of Distributed Locks with Redis and Redisson
IT Services Circle
IT Services Circle
Mar 31, 2023 · Backend Development

Understanding Distributed Locks and Implementations with Redis and Redisson

This article explains the concept of distributed locks, compares them with local JVM locks, outlines essential properties, demonstrates simple Redis-based lock implementations using SETNX and Lua scripts, discusses lock expiration and renewal, and introduces Redisson's advanced features such as automatic watchdog renewal and the Redlock algorithm.

Distributed LockJavaRedlock
0 likes · 13 min read
Understanding Distributed Locks and Implementations with Redis and Redisson
macrozheng
macrozheng
Jan 12, 2023 · Databases

Choosing the Right Java Redis Client: Jedis vs Lettuce vs Redisson

This article compares three popular Java Redis clients—Jedis, Lettuce, and Redisson—detailing their advantages, drawbacks, and recommended usage scenarios, helping developers select the most suitable client based on performance, thread safety, and advanced Redis features such as clustering, sentinel, and distributed locks.

Client ComparisonJavaJedis
0 likes · 9 min read
Choosing the Right Java Redis Client: Jedis vs Lettuce vs Redisson
ITPUB
ITPUB
Dec 25, 2022 · Backend Development

10 Hidden Pitfalls of Using Redis Distributed Locks (and How to Avoid Them)

This article examines ten common traps when implementing Redis distributed locks—ranging from non‑atomic setnx/expire operations and missing expirations to lock release ordering, re‑entrancy, master‑slave replication issues, and the Redlock algorithm—providing concrete code examples, explanations, and best‑practice solutions.

JavaRedisbackend
0 likes · 15 min read
10 Hidden Pitfalls of Using Redis Distributed Locks (and How to Avoid Them)
Java Architect Essentials
Java Architect Essentials
Nov 30, 2022 · Backend Development

Understanding Redisson Distributed Locks: Architecture, Reentrancy, Fairness, and WatchDog Mechanism

This article explains Redisson's role as a Java in‑memory data grid built on Redis, compares it with Jedis and Lettuce, and details how Redisson implements distributed locks—including simple lock/unlock, Lua‑based reentrant locks, automatic lock renewal (WatchDog), and a fair lock using Redis lists and sorted sets—providing complete code examples and execution flow.

Distributed LockLuaRedis
0 likes · 31 min read
Understanding Redisson Distributed Locks: Architecture, Reentrancy, Fairness, and WatchDog Mechanism
Java High-Performance Architecture
Java High-Performance Architecture
Nov 4, 2022 · Backend Development

Mastering Distributed Locks with Redis: From Basic SetNX to Redisson’s Atomic Solutions

This article walks through the evolution of Redis-based distributed locking—from simple SETNX placeholders and manual expiration, through atomic SETNX EX, UUID‑based lock ownership, Lua‑scripted unlocks, and finally Redisson’s high‑level lock API—highlighting common pitfalls and robust solutions for backend developers.

Distributed LockJavaRedis
0 likes · 10 min read
Mastering Distributed Locks with Redis: From Basic SetNX to Redisson’s Atomic Solutions
Cognitive Technology Team
Cognitive Technology Team
Sep 25, 2022 · Backend Development

Implementation and Pitfalls of Distributed Locks with Redis and Redisson Watchdog

This article explains the requirements for a Redis‑based distributed lock, analyzes Redisson's watchdog lock implementation—including tryLock and unlock flows, Lua atomic scripts, single‑instance versus cluster limitations—and provides practical tips to avoid common pitfalls in production environments.

Distributed Lockbackendredisson
0 likes · 6 min read
Implementation and Pitfalls of Distributed Locks with Redis and Redisson Watchdog
Sohu Tech Products
Sohu Tech Products
Aug 10, 2022 · Backend Development

Understanding Redisson Distributed Locks: Reentrancy, Fairness, and Watchdog Mechanism

This article explains how Redisson implements distributed locks on Redis, covering basic concepts, differences from Jedis and Lettuce, the Lua scripts for lock acquisition, reentrancy handling, automatic lease renewal via a watchdog, Pub/Sub based unlock notifications, and the design of a fair lock using Redis lists and sorted sets.

Distributed LockRedisWatchdog
0 likes · 30 min read
Understanding Redisson Distributed Locks: Reentrancy, Fairness, and Watchdog Mechanism
Code Ape Tech Column
Code Ape Tech Column
Aug 4, 2022 · Backend Development

Understanding Redisson Distributed Lock Implementation

This article provides a comprehensive, step‑by‑step analysis of Redisson’s distributed lock implementation, covering its architecture, Lua scripts for lock acquisition, re‑entrancy, watchdog renewal, unlocking, fair lock mechanisms, and code examples, enabling developers to grasp and apply robust Redis‑based locking in Java applications.

Distributed LockJavaLua
0 likes · 31 min read
Understanding Redisson Distributed Lock Implementation