BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 18 of 36
Python Programming Learning Circle
Python Programming Learning Circle
Sep 26, 2022 · Backend Development

Comprehensive Guide to Using Celery for Asynchronous Task Processing in Python

This article provides a detailed tutorial on Celery, covering its architecture, installation, task structures, basic and advanced usage, integration with Django, and code examples for creating workers, scheduling tasks, and retrieving results, enabling developers to implement robust asynchronous processing in Python applications.

Asynchronous TasksDjangoPython
0 likes · 13 min read
Comprehensive Guide to Using Celery for Asynchronous Task Processing in Python
Selected Java Interview Questions
Selected Java Interview Questions
Sep 25, 2022 · Backend Development

Understanding Component Implementation Principles for Technical Interviews

The article explains why interviewers probe the implementation details of backend components such as Redis, HashMap, and Memcached, illustrates common interview questions, and shows how mastering the underlying data structures, algorithms, and memory‑allocation mechanisms can improve both interview performance and real‑world problem solving.

AlgorithmsData StructuresHashMap
0 likes · 8 min read
Understanding Component Implementation Principles for Technical Interviews
Java Architect Essentials
Java Architect Essentials
Sep 23, 2022 · Databases

Redis Set and Sorted Set Internal Encodings: intset, Hashtable, Skiplist and Ziplist

This article explains why Redis stores set and sorted‑set objects using two different internal encodings, describes the intset and hashtable representations for sets, the skiplist and ziplist representations for sorted sets, shows the upgrade process with code examples, and lists the common commands for manipulating these data structures.

Data StructuresRedisSet
0 likes · 16 min read
Redis Set and Sorted Set Internal Encodings: intset, Hashtable, Skiplist and Ziplist
FunTester
FunTester
Sep 21, 2022 · Backend Development

Mastering Go Redis Set Operations: API Guide and Performance Benchmark

This article provides a comprehensive guide to implementing and testing Go Redis Set APIs—including SAdd, SCard, SIsMember, SMembers, SRem, SPop, and SPopN—complete with code examples, a unified test suite, and a performance benchmark that reports QPS and execution time.

APIGoPerformance
0 likes · 8 min read
Mastering Go Redis Set Operations: API Guide and Performance Benchmark
ITPUB
ITPUB
Sep 20, 2022 · Backend Development

How to Build a High‑Performance Game Event Queue with Redis and Lua

This article explains how to design a Redis‑based pseudo‑message queue that groups, limits, and batch‑processes game‑level behavior data using Lua scripts, achieving millisecond‑level latency, controlled queue length, and scalable production‑consumer throughput for large‑scale game analytics.

Game AnalyticsLuaMessage Queue
0 likes · 14 min read
How to Build a High‑Performance Game Event Queue with Redis and Lua
Open Source Linux
Open Source Linux
Sep 19, 2022 · Databases

Master RedisInsight: Install, Configure, and Use on Linux & Kubernetes

RedisInsight is a powerful GUI for Redis that enables monitoring, CLI interaction, and module support; this guide walks through its features, step‑by‑step installation on physical servers and Kubernetes, environment configuration, service startup, and basic usage including memory analysis and data operations.

Database GUIInstallationKubernetes
0 likes · 7 min read
Master RedisInsight: Install, Configure, and Use on Linux & Kubernetes
Architect
Architect
Sep 19, 2022 · Databases

Redis Architecture: From Single‑Threaded Core to Multi‑Threaded I/O and BIO Evolution

This article explains how Redis evolved from a single‑threaded event‑loop architecture using I/O multiplexing and the Reactor pattern to a multi‑threaded I/O model and an enhanced BIO system with lazyfree, detailing design decisions, source‑code excerpts, performance impacts, and practical lessons for developers.

Database ArchitectureRedislazyfree
0 likes · 44 min read
Redis Architecture: From Single‑Threaded Core to Multi‑Threaded I/O and BIO Evolution
Java Architect Essentials
Java Architect Essentials
Sep 18, 2022 · Databases

Redis vs Dragonfly: Benchmark Comparison and Architectural Insights

This article examines the open‑source memory cache Dragonfly, compares its performance and architecture against Redis through detailed benchmark results, discusses Redis’s response and design principles, and provides reproducible test configurations and command lines for both systems.

DragonflyMemory CachePerformance
0 likes · 16 min read
Redis vs Dragonfly: Benchmark Comparison and Architectural Insights
ITPUB
ITPUB
Sep 18, 2022 · Databases

Master Redis Memory: 7 Proven Techniques to Store More Data with Less RAM

This article explains how Redis stores key‑value pairs, details the internal data structures such as dict, dictEntry and redisObject, and provides practical memory‑saving tricks—including key shortening, encoding choices, object sharing, bitmap usage, hash consolidation, fragmentation handling, and 32‑bit deployment—to dramatically reduce RAM consumption while maintaining performance.

CacheData StructuresDatabase
0 likes · 19 min read
Master Redis Memory: 7 Proven Techniques to Store More Data with Less RAM
dbaplus Community
dbaplus Community
Sep 17, 2022 · Databases

Choosing the Right Redis Deployment: Features, Architectures, and Best Practices

This article examines Redis 6.0 and 5.0 new features, compares various deployment architectures—including master‑replica, cluster, and read/write‑split—and provides practical guidance, code examples, and performance considerations to help engineers select the optimal Redis setup for production environments.

ClusterDatabase ArchitectureMaster-Replica
0 likes · 12 min read
Choosing the Right Redis Deployment: Features, Architectures, and Best Practices
Open Source Linux
Open Source Linux
Sep 15, 2022 · Databases

Master RedisInsight: Install, Deploy on Kubernetes, and Unlock Redis Monitoring

RedisInsight is a powerful GUI for Redis that offers cluster support, SSL/TLS connections, and memory analysis; this guide walks you through its features, step‑by‑step physical and Kubernetes installations, environment configuration, service startup, and basic usage for monitoring and managing Redis instances.

Database ManagementKubernetesRedis
0 likes · 7 min read
Master RedisInsight: Install, Deploy on Kubernetes, and Unlock Redis Monitoring
Java Architect Essentials
Java Architect Essentials
Sep 15, 2022 · Databases

Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Model, and I/O Multiplexing

Redis achieves exceptional speed by operating as an in‑memory database, leveraging compact data structures like SDS, linked lists, hash tables, skip lists and ziplists, running a single‑threaded event loop with I/O multiplexing, and employing optimizations such as lazy‑free, progressive rehashing, and multithreaded network I/O.

Data StructuresI/O multiplexingPerformance Optimization
0 likes · 18 min read
Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Model, and I/O Multiplexing
Top Architect
Top Architect
Sep 15, 2022 · Databases

Understanding Redis Master‑Slave Replication: Principles, Configuration, Workflow, and Common Pitfalls

This article explains the CAP theorem, details how Redis implements master‑slave replication—including its asynchronous nature, configuration methods, three‑phase workflow, heartbeat mechanism, and common operational issues—providing practical guidance for building highly available Redis deployments.

CAP theoryMaster‑SlaveRedis
0 likes · 16 min read
Understanding Redis Master‑Slave Replication: Principles, Configuration, Workflow, and Common Pitfalls
ITPUB
ITPUB
Sep 9, 2022 · Databases

Can Redis Streams Replace Kafka? A Practical Comparison

While Kafka dominates large‑scale messaging, this article shows how Redis Streams—an in‑memory, low‑cost alternative—can handle peak‑shaving, buffering, decoupling, redundancy, and robustness, offering simpler commands and higher speed for projects where deploying a full Kafka stack is overkill.

In-Memory DatabaseMessage QueueRedis
0 likes · 7 min read
Can Redis Streams Replace Kafka? A Practical Comparison
Past Memory Big Data
Past Memory Big Data
Sep 8, 2022 · Backend Development

Implementing Fixed-Length Queues and Batch Consumption in Redis with Lua

The article details how a gaming data‑reporting pipeline uses Redis lists, sets and Lua scripts to build a pseudo‑message queue that provides per‑game message grouping, fixed‑length queues, and batch consumption while meeting strict timeliness and throughput requirements.

Batch ProcessingFixed-length queueLua
0 likes · 12 min read
Implementing Fixed-Length Queues and Batch Consumption in Redis with Lua
21CTO
21CTO
Sep 6, 2022 · Databases

Best Practices for Using Alibaba Cloud Redis: Key Design, Commands, and Client Tips

This guide outlines comprehensive best‑practice recommendations for Alibaba Cloud Redis, covering readable key naming, value size limits, safe command usage, client connection pooling, encryption, eviction policies, and efficient big‑key deletion techniques to improve performance and reliability.

Alibaba CloudBigKey ManagementClient Best Practices
0 likes · 11 min read
Best Practices for Using Alibaba Cloud Redis: Key Design, Commands, and Client Tips
Top Architect
Top Architect
Sep 3, 2022 · Backend Development

Implementing Distributed Locks with Redis, Zookeeper, and etcd

The article explains how to build reliable distributed locks using Redis, Zookeeper, and etcd, describing the essential concepts of mutual exclusion, safety, and liveness, showing code examples, highlighting common issues, and comparing each solution's advantages and drawbacks.

RedisZookeeperconcurrency
0 likes · 6 min read
Implementing Distributed Locks with Redis, Zookeeper, and etcd
Su San Talks Tech
Su San Talks Tech
Sep 3, 2022 · Databases

Dragonfly vs Redis: Does the New Cache System Really Outperform?

An in‑depth comparison shows that while Dragonfly claims to be the world’s fastest memory cache, Redis 7.0 often delivers higher throughput and lower latency across multiple benchmark scenarios, highlighting architectural trade‑offs and the potential for future feature adoption from Dragonfly into Redis.

DragonflyIn-Memory CachePerformance
0 likes · 19 min read
Dragonfly vs Redis: Does the New Cache System Really Outperform?
dbaplus Community
dbaplus Community
Sep 3, 2022 · Backend Development

Can Redis Streams Replace Kafka for Your Messaging Needs?

The article explains how Redis Streams offers a lightweight, memory‑based alternative to Kafka, detailing its features, consumer‑group model, performance advantages, and suitable use cases while acknowledging scenarios where a full‑featured message queue remains preferable.

KafkaMessage QueueRedis
0 likes · 7 min read
Can Redis Streams Replace Kafka for Your Messaging Needs?
IT Architects Alliance
IT Architects Alliance
Aug 31, 2022 · Databases

Redis Persistence Mechanisms: RDB Snapshots, AOF Logging, and Hybrid Persistence

This article explains Redis's persistence strategies—including RDB snapshotting with Copy‑On‑Write, AOF command logging with configurable fsync policies, and the hybrid persistence introduced in Redis 4.0—detailing their implementation, performance trade‑offs, configuration options, and practical usage examples.

AOFConfigurationCopy-on-Write
0 likes · 12 min read
Redis Persistence Mechanisms: RDB Snapshots, AOF Logging, and Hybrid Persistence
ITPUB
ITPUB
Aug 31, 2022 · Databases

How Redis Implements Multithreading: A Deep Dive into Its I/O Thread Model

This article explains Redis's single‑threaded architecture, its limitations, and how Redis 6.0+ adds configurable I/O threads to parallelize read/write handling, detailing the server initialization, event loop, task queues, and the interaction between the main thread and worker threads.

I/O ThreadsRedisServer Architecture
0 likes · 27 min read
How Redis Implements Multithreading: A Deep Dive into Its I/O Thread Model
Top Architect
Top Architect
Aug 31, 2022 · Backend Development

Implementing a Reliable Delay Queue with Redis and Go

This article explains how to build a precise, persistent delay queue using Redis data structures and Lua scripts, demonstrates a Go client library with code examples for sending, consuming, acknowledging, and retrying delayed messages, and discusses the design requirements such as durability, retry mechanisms, and timing accuracy.

GoLuaMessage Queue
0 likes · 13 min read
Implementing a Reliable Delay Queue with Redis and Go
Java Tech Enthusiast
Java Tech Enthusiast
Aug 31, 2022 · Databases

Redis Persistence, Transactions, and Distributed Locks

Redis ensures data durability through RDB snapshots and AOF logs—configurable for location, compression, and sync policies—while offering atomic transactions via MULTI/EXEC and simple distributed locks using SETNX (optionally guarded by WATCH) with expirations to prevent deadlocks.

AOFPersistenceRDB
0 likes · 11 min read
Redis Persistence, Transactions, and Distributed Locks
Architecture Digest
Architecture Digest
Aug 31, 2022 · Backend Development

Implementing a Reliable Delay Queue with Redis and Go

This article explains how to build a reliable delayed message queue using Redis, covering business scenarios, requirements such as persistence and retry, the design of Redis data structures, Lua scripts for atomic operations, and a Go implementation with example code for producing and consuming delayed tasks.

GoLuaMessage Queue
0 likes · 13 min read
Implementing a Reliable Delay Queue with Redis and Go
Su San Talks Tech
Su San Talks Tech
Aug 29, 2022 · Databases

Why Redis Added Multithreading in 6.0: Design Rationale and Trade‑offs

This article explains why Redis, originally designed as a single‑threaded in‑memory database, introduced a multithreaded network layer in version 6.0, covering the historical design, the limits of CPU vs I/O utilization, the role of I/O multiplexing, and the benefits and drawbacks of the new model.

I/O multiplexingRedisconcurrency
0 likes · 11 min read
Why Redis Added Multithreading in 6.0: Design Rationale and Trade‑offs
dbaplus Community
dbaplus Community
Aug 25, 2022 · Backend Development

Mastering Distributed Locks: From Basics to Redlock and Beyond

This comprehensive guide explains why distributed locks are needed, outlines their three essential properties, compares common implementations such as Redis, MySQL, ZooKeeper, and Redlock, discusses pitfalls like non‑atomic operations and lock expiration, and presents correct patterns using atomic commands, Lua scripts, watchdogs, and fencing tokens.

LuaMySQLRedis
0 likes · 37 min read
Mastering Distributed Locks: From Basics to Redlock and Beyond
Tencent Cloud Developer
Tencent Cloud Developer
Aug 24, 2022 · Backend Development

Go Distributed ID Generation: UUID, ShortUUID, XID, KSUID, ULID, Snowflake, and Segment Modes

The article surveys Go‑based distributed ID generation techniques—from UUID, short‑UUID, XID, KSUID, ULID, and Snowflake to database auto‑increment, Redis, ZooKeeper, and segment/leaf approaches—detailing their characteristics, trade‑offs, implementation snippets, and strategies for ordering, uniqueness, and clock‑rollback handling.

DatabaseGoRedis
0 likes · 12 min read
Go Distributed ID Generation: UUID, ShortUUID, XID, KSUID, ULID, Snowflake, and Segment Modes
Java High-Performance Architecture
Java High-Performance Architecture
Aug 23, 2022 · Backend Development

How to Build a Million‑User Ticket‑Snatching System with Go, Nginx, and Redis

This article explores the architecture and implementation of a high‑concurrency ticket‑snatching system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Redis‑based inventory management, and Go code examples that together enable handling millions of simultaneous requests while preventing overselling and ensuring high availability.

GoRedishigh-concurrency
0 likes · 20 min read
How to Build a Million‑User Ticket‑Snatching System with Go, Nginx, and Redis
IT Architects Alliance
IT Architects Alliance
Aug 21, 2022 · Backend Development

How to Build a Scalable Delayed Queue with Redis and Java

This article explains why delayed queues are needed for scenarios like unpaid orders or auto‑generated comments, compares built‑in and third‑party solutions, and provides a detailed design and implementation guide for a Redis‑based delayed‑queue service, including version‑1.0 features, version‑2.0 optimizations, and multi‑node deployment.

Delayed QueueJavaMessage Queue
0 likes · 9 min read
How to Build a Scalable Delayed Queue with Redis and Java
Top Architect
Top Architect
Aug 20, 2022 · Backend Development

Design and Implementation of a Redis‑Based Delayed Queue Service

This article explains the business scenarios that require delayed processing, compares several delay‑queue solutions such as Java's DelayQueue, RocketMQ and RabbitMQ, and then details a custom Redis‑backed delayed‑queue architecture (1.0 and 2.0 versions) with Zookeeper coordination, pull‑job and worker threads for high‑availability and real‑time message delivery.

Delayed QueueJavaMessage Queue
0 likes · 8 min read
Design and Implementation of a Redis‑Based Delayed Queue Service
Shepherd Advanced Notes
Shepherd Advanced Notes
Aug 18, 2022 · Databases

Is Redis Really Single‑Threaded? Exploring Redis 6.0 Multithreading and Bottlenecks

The article explains why Redis has traditionally been single‑threaded, details the new IO‑thread multithreading model introduced in Redis 6.0, walks through its four processing stages, lists essential INFO monitoring commands, examines memory overhead of strings versus hashes, compares List and Sorted Set ordering, and identifies five key performance‑blocking points.

Blocking operationsINFO commandIO threads
0 likes · 17 min read
Is Redis Really Single‑Threaded? Exploring Redis 6.0 Multithreading and Bottlenecks
21CTO
21CTO
Aug 16, 2022 · Backend Development

Mastering Fast File Uploads: Instant Transfer, Chunked Upload, and Resume Techniques

This article explains how to achieve efficient large‑file uploads by using instant (MD5‑based) transfer, chunked uploading, and breakpoint resume, detailing the underlying Redis logic, server‑side Java implementations with RandomAccessFile and MappedByteBuffer, and practical deployment considerations such as file servers and OSS.

Chunked UploadFastDFSJava
0 likes · 15 min read
Mastering Fast File Uploads: Instant Transfer, Chunked Upload, and Resume Techniques
Top Architect
Top Architect
Aug 15, 2022 · Backend Development

Solving Distributed Session Issues in Microservices with Spring Session and Redis

This article explains the challenges of distributed session management in microservice architectures and presents four solution approaches, focusing on a Java implementation using Spring Session with Redis, including dependency setup, configuration, login logic, controller handling, and verification through testing.

Distributed SessionJavaRedis
0 likes · 8 min read
Solving Distributed Session Issues in Microservices with Spring Session and Redis
ITPUB
ITPUB
Aug 14, 2022 · Backend Development

Mastering Redis Bitmap for Efficient Binary State Statistics in Mobile Apps

This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.

Binary StatisticsBitMapData Structures
0 likes · 11 min read
Mastering Redis Bitmap for Efficient Binary State Statistics in Mobile Apps
Shepherd Advanced Notes
Shepherd Advanced Notes
Aug 12, 2022 · Databases

Understanding Redis: Core Data Structures and Essential Commands

This article explains why Redis’s single‑threaded design achieves high performance, details its five fundamental data types—string, list, set, hash, and sorted set—their internal implementations, and introduces advanced structures such as Geo, Bitmap, and HyperLogLog with practical command examples.

BitMapData StructuresGeospatial
0 likes · 23 min read
Understanding Redis: Core Data Structures and Essential Commands
Architect's Guide
Architect's Guide
Aug 11, 2022 · Backend Development

Design and Implementation of a Redis-Based Delayed Queue Service

The article explains the need for delayed processing in business scenarios, compares various delayed queue solutions such as Java DelayQueue, RocketMQ, and RabbitMQ, and details a Redis-based implementation with message storage, ZSET queues, pull jobs, workers, and Zookeeper coordination for high availability.

Delayed QueueRedisbackend
0 likes · 6 min read
Design and Implementation of a Redis-Based Delayed Queue Service
Su San Talks Tech
Su San Talks Tech
Aug 11, 2022 · Backend Development

How to Choose the Right Distributed ID Generator for Your System

This article examines common distributed ID generation strategies—including UUID, Snowflake-like algorithms, database auto‑increment, and Redis atomic increment—detailing their requirements, advantages, drawbacks, and suitable scenarios to help engineers select the most appropriate solution for high‑performance, secure systems.

Redisdistributed IDsnowflake
0 likes · 12 min read
How to Choose the Right Distributed ID Generator for Your System
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.

RedisRedissondistributed lock
0 likes · 30 min read
Understanding Redisson Distributed Locks: Reentrancy, Fairness, and Watchdog Mechanism
Sohu Tech Products
Sohu Tech Products
Aug 10, 2022 · Backend Development

Designing a High-Concurrency Ticket Booking System with Load Balancing, Nginx Weighted Round Robin, and Redis

This article presents a comprehensive design and implementation of a high‑concurrency train‑ticket flash‑sale system, covering distributed architecture, load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based services, Redis‑backed stock management, and performance testing results.

Distributed ArchitectureRedishigh-concurrency
0 likes · 20 min read
Designing a High-Concurrency Ticket Booking System with Load Balancing, Nginx Weighted Round Robin, and Redis
IT Architects Alliance
IT Architects Alliance
Aug 10, 2022 · Databases

Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Model, and I/O Multiplexing

Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, ziplist and skiplist, running a single‑threaded event loop with lock‑free execution, and employing efficient I/O multiplexing and incremental rehash techniques to minimize latency and maximize throughput.

I/O multiplexingIn-Memory DatabaseRedis
0 likes · 17 min read
Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Model, and I/O Multiplexing
Top Architect
Top Architect
Aug 9, 2022 · Backend Development

Building a Spring Boot Lottery System with Redis and MyBatis‑Plus

This article demonstrates how to create a simple lottery application using Spring Boot, MyBatis‑Plus, and Redis, covering project setup, database schema, dependency configuration, Redis integration, event‑driven data initialization, lottery draw logic, stock management, and asynchronous record handling.

JavaLotteryRedis
0 likes · 23 min read
Building a Spring Boot Lottery System with Redis and MyBatis‑Plus
Top Architect
Top Architect
Aug 9, 2022 · Databases

Why Redis Is Fast: In‑Memory Design, Specialized Data Structures, Single‑Threaded Execution and I/O Multiplexing

Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, hash tables, skip‑lists and zip‑lists, running a single‑threaded event loop with I/O multiplexing, and applying optimisations like lazy‑free, progressive rehashing and optional multi‑threaded I/O for network traffic.

Data StructuresI/O multiplexingIn-Memory Database
0 likes · 18 min read
Why Redis Is Fast: In‑Memory Design, Specialized Data Structures, Single‑Threaded Execution and I/O Multiplexing
Senior Brother's Insights
Senior Brother's Insights
Aug 8, 2022 · Databases

How to Install and Use RedisInsight for Redis Cluster Management

RedisInsight is a powerful GUI for Redis that supports cluster management, SSL connections, and memory analysis; this guide walks through downloading, installing on Linux, configuring environment variables, running as a service, deploying via Kubernetes, and using the web UI to monitor and operate Redis instances.

Database ManagementGUIInstallation
0 likes · 7 min read
How to Install and Use RedisInsight for Redis Cluster Management
Architect's Guide
Architect's Guide
Aug 8, 2022 · Backend Development

Cache Consistency Strategies: Updating Database and Cache, Deleting Cache, and Handling Inconsistencies

The article explains why caching is essential for high‑traffic read‑heavy services, analyzes the consistency problems that arise when data exists simultaneously in MySQL and Redis, compares four cache‑update strategies, and provides practical recommendations such as using expiration, delayed double‑delete, message queues, and binlog subscription to achieve eventual consistency.

Cache ConsistencyMySQLRedis
0 likes · 18 min read
Cache Consistency Strategies: Updating Database and Cache, Deleting Cache, and Handling Inconsistencies
Top Architect
Top Architect
Aug 6, 2022 · Backend Development

Practical Coding Techniques: Kafka Transaction Commit, Redis Distributed Lock Simplification, and Business Log Decoupling

This article shares several practical coding techniques for backend development, including how to commit Kafka transactions safely, simplify Redis distributed lock usage with Redisson, implement AOP-based method locking, and decouple business logging using thread pools and asynchronous processing.

AOPRedisdistributed lock
0 likes · 13 min read
Practical Coding Techniques: Kafka Transaction Commit, Redis Distributed Lock Simplification, and Business Log Decoupling
Java Backend Technology
Java Backend Technology
Aug 6, 2022 · Backend Development

How to Prevent Coupon Over‑Issuing in High‑Concurrency Scenarios

The article analyzes why a coupon‑distribution feature can issue more coupons than available under heavy load, explains the root cause of concurrent stock deductions, and presents four practical solutions—including Java synchronized blocks, SQL row‑level locking, Redis distributed locks, and Redisson—to reliably prevent over‑issuance.

JavaMySQLRedis
0 likes · 11 min read
How to Prevent Coupon Over‑Issuing in High‑Concurrency Scenarios
IT Architects Alliance
IT Architects Alliance
Aug 6, 2022 · Backend Development

Practical Coding Tips: Kafka Transaction Commit, Redis Distributed Lock Simplification, AOP Lock Annotation, and Business Log Decoupling

This article shares practical development techniques, including how to safely commit Kafka messages within transactions, simplify Redis distributed locks with Redisson, implement an AOP‑based lock annotation for method-level locking, and decouple business logging using asynchronous thread pools and helper utilities.

AOPJavaKafka
0 likes · 14 min read
Practical Coding Tips: Kafka Transaction Commit, Redis Distributed Lock Simplification, AOP Lock Annotation, and Business Log Decoupling
Selected Java Interview Questions
Selected Java Interview Questions
Aug 5, 2022 · Backend Development

Understanding Interface Call Idempotency and Practical Solutions for Backend Systems

The article explains the concept of interface call idempotency in distributed micro‑service architectures, outlines scenarios that cause idempotency problems, and presents practical solutions such as token mechanisms, various lock strategies, unique constraints, deduplication tables, and global request IDs, with code examples in Java and Redis.

JavaLocksRedis
0 likes · 13 min read
Understanding Interface Call Idempotency and Practical Solutions for Backend Systems
Code Ape Tech Column
Code Ape Tech Column
Aug 5, 2022 · Backend Development

Implementing Fast File Upload: Instant Upload, Chunked Upload, and Resume Upload with Java Backend

This article explains the concepts and implementation details of instant (秒传) upload, chunked (分片) upload, and breakpoint resume upload, providing Java backend code using Redis, RandomAccessFile, and MappedByteBuffer to achieve efficient large‑file transfer with MD5 deduplication and progress tracking.

Chunked UploadRedisresume upload
0 likes · 12 min read
Implementing Fast File Upload: Instant Upload, Chunked Upload, and Resume Upload with Java Backend
IT Architects Alliance
IT Architects Alliance
Aug 4, 2022 · Information Security

Understanding Session Mechanisms, Distributed Session Challenges, and SSO Solutions with CAS Implementation

This article explains traditional session and authentication mechanisms, the problems of session sharing in clustered and multi‑service environments, and presents practical SSO solutions—including CAS‑based single sign‑on and its differences from OAuth2—accompanied by complete Java Spring code examples.

AuthenticationCASJava
0 likes · 16 min read
Understanding Session Mechanisms, Distributed Session Challenges, and SSO Solutions with CAS Implementation
Top Architect
Top Architect
Aug 4, 2022 · Backend Development

Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Redis, and Go

This article explains how to build a high‑concurrency ticket‑seckill service that can handle millions of requests by combining distributed load‑balancing (OSPF, LVS, Nginx weighted round‑robin), a pre‑deduction stock strategy using local memory and Redis with Lua scripts, and a Go‑based HTTP server, and it demonstrates performance testing results.

GoRedisSeckill
0 likes · 19 min read
Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Redis, and Go
Architect
Architect
Aug 3, 2022 · Information Security

Understanding Session Mechanisms, Session Sharing, and SSO with CAS Implementation

This article explains the challenges of multiple system logins, reviews traditional HTTP session handling, presents session sharing solutions like replication and Redis‑based central storage, and details a CAS‑based single sign‑on implementation with code examples, while also comparing CAS to OAuth2.

CASJavaRedis
0 likes · 13 min read
Understanding Session Mechanisms, Session Sharing, and SSO with CAS Implementation
IT Architects Alliance
IT Architects Alliance
Jul 31, 2022 · Databases

Why Redis Uses Dual Data Structures for Sets and Sorted Sets

This article explains how Redis internally stores set and sorted‑set objects using intset, hashtable, ziplist, and skiplist encodings, the conditions that trigger each representation, the upgrade process, and the essential Redis commands for manipulating these data structures.

Data StructuresDatabaseRedis
0 likes · 16 min read
Why Redis Uses Dual Data Structures for Sets and Sorted Sets
Top Architect
Top Architect
Jul 31, 2022 · Backend Development

Design and Implementation of Delayed Message Queues in Distributed Systems

This article surveys common delayed‑message solutions in distributed asynchronous messaging, evaluates implementations based on external storage, databases, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar and QMQ, and discusses their advantages, drawbacks, and practical design considerations.

Delayed MessagingRedisRocketMQ
0 likes · 13 min read
Design and Implementation of Delayed Message Queues in Distributed Systems
Java Backend Technology
Java Backend Technology
Jul 31, 2022 · Backend Development

Mastering Single Sign-On (SSO) with CAS: From Session Basics to Full Demo

This article explains why unified authentication is essential for product suites, reviews traditional session mechanisms and their limitations in clustered environments, explores session‑sharing strategies, introduces CAS‑based SSO workflows, compares CAS with OAuth2, and provides a complete Spring Boot demo with code snippets and configuration details.

AuthenticationCASRedis
0 likes · 17 min read
Mastering Single Sign-On (SSO) with CAS: From Session Basics to Full Demo
ITPUB
ITPUB
Jul 30, 2022 · Databases

How to Choose the Right Redis Memory Eviction Policy and Size Your Cache

When expired keys accumulate and lazy deletion can't keep up, Redis relies on configurable memory eviction policies and proper maxmemory settings, and selecting the appropriate strategy along with an optimal cache size (typically 15‑30% of total data) ensures stable performance and avoids out‑of‑memory errors.

Cache SizingRediseviction policies
0 likes · 7 min read
How to Choose the Right Redis Memory Eviction Policy and Size Your Cache
Top Architect
Top Architect
Jul 29, 2022 · Backend Development

Implementing API Idempotency in Spring Boot Using Tokens, Database Primary Keys, Optimistic Locks, and Redis

This article explains the concept of idempotency in computing and HTTP, why it is essential for APIs, the impact on system design, which RESTful methods are idempotent, and presents four practical implementation strategies—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples and testing procedures.

APIDatabaseJava
0 likes · 22 min read
Implementing API Idempotency in Spring Boot Using Tokens, Database Primary Keys, Optimistic Locks, and Redis
Java High-Performance Architecture
Java High-Performance Architecture
Jul 28, 2022 · Backend Development

How to Accelerate Complex Search Queries with Redis Caching and SQL Optimization

This article walks through three progressive implementations for handling intricate e‑commerce search filters—starting with a raw SQL approach, then optimizing with indexed queries and split statements, and finally leveraging Redis sets and sorted sets for caching, pagination, and high‑performance query execution.

Redisbackendcaching
0 likes · 8 min read
How to Accelerate Complex Search Queries with Redis Caching and SQL Optimization
IT Architects Alliance
IT Architects Alliance
Jul 27, 2022 · Backend Development

Mastering API Idempotency: Strategies, Code Samples, and Best Practices

This article explains the concept of idempotency, why it matters for HTTP APIs, compares the idempotent characteristics of RESTful methods, and presents four practical implementation strategies—including database primary keys, optimistic locking, Redis‑based tokens, and downstream sequence numbers—along with complete Spring Boot code examples and testing guidance.

APIJavaRedis
0 likes · 24 min read
Mastering API Idempotency: Strategies, Code Samples, and Best Practices
Architect's Guide
Architect's Guide
Jul 27, 2022 · Backend Development

Design and Implementation of Delayed Messaging in Distributed Systems

This article surveys common delayed‑message solutions—including database, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar, and QMQ—explaining their architectures, advantages, drawbacks, and practical considerations for building reliable distributed asynchronous messaging.

Delayed MessagingRedisRocketMQ
0 likes · 13 min read
Design and Implementation of Delayed Messaging in Distributed Systems
IT Architects Alliance
IT Architects Alliance
Jul 25, 2022 · Backend Development

Design and Implementation of Distributed Lock Services: Redis, ZooKeeper, and SharkLock

The article explains the principles, requirements, and common implementations of distributed lock services using Redis and ZooKeeper, analyzes their drawbacks, and introduces SharkLock's design choices—including lock metadata, reliability via SharkStore, dead‑lock prevention, safety mechanisms, and Raft‑based consistency—to guide developers in building robust distributed locking solutions.

RaftRedisSharkLock
0 likes · 15 min read
Design and Implementation of Distributed Lock Services: Redis, ZooKeeper, and SharkLock
Selected Java Interview Questions
Selected Java Interview Questions
Jul 25, 2022 · Backend Development

Four Approaches to Solving Session Management in Distributed Environments

This article examines four strategies for handling session data in distributed backend systems—session replication, client-side storage, hash-based load balancing, and centralized storage with Redis—detailing their principles, advantages, disadvantages, and practical recommendations for different deployment scales.

Redisbackenddistributed systems
0 likes · 9 min read
Four Approaches to Solving Session Management in Distributed Environments
Senior Brother's Insights
Senior Brother's Insights
Jul 24, 2022 · Databases

Understanding Redis High Availability: Master‑Slave, Sentinel, and Cluster Explained

This article explains why single‑node Redis suffers from single‑point failures, describes the master‑slave replication model, details the Sentinel automatic failover mechanism, compares various sharding solutions like client‑side sharding, Twemproxy, Codis, and outlines the features and deployment considerations of Redis Cluster.

ClusterDatabaseRedis
0 likes · 19 min read
Understanding Redis High Availability: Master‑Slave, Sentinel, and Cluster Explained
Architecture Digest
Architecture Digest
Jul 21, 2022 · Backend Development

Implementing a Reliable Redis‑Based Delay Queue in Go

This article explains how to design and implement a precise, persistent, and retry‑capable delay queue using Redis ordered sets and Lua scripts, provides a complete Go library with usage examples, and discusses the underlying data structures, atomic operations, and garbage‑collection mechanisms.

GoMessage QueueRedis
0 likes · 11 min read
Implementing a Reliable Redis‑Based Delay Queue in Go
IT Architects Alliance
IT Architects Alliance
Jul 20, 2022 · Backend Development

Preventing Coupon Over‑Issuance in High‑Concurrency Scenarios: Java Locks, SQL Constraints, and Redis Distributed Locks

This article analyzes the coupon over‑issuance issue caused by concurrent requests, demonstrates how simple SQL updates can fail under load, and presents four solutions—including Java synchronized blocks, SQL row‑level locking, optimistic locking, and Redis‑based distributed locks with Redisson—to ensure atomic coupon allocation.

JavaRedisSQL
0 likes · 11 min read
Preventing Coupon Over‑Issuance in High‑Concurrency Scenarios: Java Locks, SQL Constraints, and Redis Distributed Locks