BestHub
Sign in
Tagged articles

message queue

1072 articles · Page 1 of 11
liandk
liandk
Oct 4, 2026 · Backend Development

High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection

This article details a production-grade five-layer architecture for high-concurrency flash sale systems, covering traffic shaping via message queues, multi-level rate limiting, three-tier overselling prevention using Redis atomic operations and database optimistic locking, and solutions for cache penetration, breakdown, and avalanche, plus nine common failure scenarios and a troubleshooting SOP.

Rediscache protectiondistributed lock
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
Java Architect Handbook
Java Architect Handbook
Sep 29, 2026 · Backend Development

DiDi Interview Deep-Dive: Solving Elasticsearch-MySQL Data Consistency

This article analyzes four patterns for keeping Elasticsearch synchronized with MySQL — synchronous dual-write, message-queue async, CDC via Canal/binlog, and scheduled reconciliation — explaining why CDC with version-based deduplication and periodic checksums is the production-grade choice for eventual consistency at scale.

CDCCanalElasticsearch
0 likes · 16 min read
DiDi Interview Deep-Dive: Solving Elasticsearch-MySQL Data Consistency
liandk
liandk
Sep 25, 2026 · Backend Development

MQ Production Failure Troubleshooting: Message Loss, Duplicates, Backlog & Dead Letters

This comprehensive guide covers the five critical MQ production failures — message loss, duplicate consumption, massive backlog, consumer hangs, and dead letter queue blocking — with root cause analysis, emergency mitigation steps, and long-term architectural fixes for RocketMQ, Kafka, and RabbitMQ.

KafkaMQRabbitMQ
0 likes · 14 min read
MQ Production Failure Troubleshooting: Message Loss, Duplicates, Backlog & Dead Letters
dbaplus Community
dbaplus Community
Sep 20, 2026 · Databases

SQLite: The Embedded Database That Replaces Solr, MongoDB, Kafka, and More

This article argues that SQLite, often dismissed as a toy database, can replace specialized systems like Elasticsearch, MongoDB, Kafka, ClickHouse, Redis, and even microservices due to its stability, zero-configuration deployment, built-in full-text search, JSON support, vector extensions, and local-first architecture, reducing operational complexity.

CachingFTS5JSON
0 likes · 25 min read
SQLite: The Embedded Database That Replaces Solr, MongoDB, Kafka, and More
Java Tech Workshop
Java Tech Workshop
Sep 20, 2026 · Backend Development

Order Timeout Auto-Cancellation: RabbitMQ Delayed Queue + Scheduled Task Dual Insurance Pattern

This article details a production-ready dual-insurance pattern for e-commerce order timeout cancellation, combining RabbitMQ delayed message queues for real-time processing with scheduled database scans as a fallback, including Spring Boot implementation code, idempotent cancellation logic, and distributed deployment considerations.

RabbitMQSpring Bootdelayed queue
0 likes · 16 min read
Order Timeout Auto-Cancellation: RabbitMQ Delayed Queue + Scheduled Task Dual Insurance Pattern
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 19, 2026 · Backend Development

Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns

This article details the architecture and implementation of a production-grade notification center that abstracts channel differences, uses Thymeleaf for template rendering, employs Channel/Provider abstractions for multi-vendor support, handles async execution via thread pools and message queues, and ensures reliability through persistent task tracking, exponential backoff retries, rate limiting, idempotency, and audit logging.

Audit LoggingRetry PatternSpring Boot
0 likes · 24 min read
Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns
Raymond Ops
Raymond Ops
Sep 14, 2026 · Operations

RocketMQ Production Operations: Cluster Setup, Retry Mechanisms & Dead Letter Queue Solutions

This comprehensive guide covers RocketMQ production operations including cluster deployment with NameServer and Broker configurations, message retry mechanisms with backoff strategies, dead letter queue handling and reprocessing, monitoring with Prometheus alerts, and troubleshooting procedures for common issues like message accumulation, disk full, and broker failures.

Cluster DeploymentOperationsRetry Mechanism
0 likes · 67 min read
RocketMQ Production Operations: Cluster Setup, Retry Mechanisms & Dead Letter Queue Solutions
Code Farming
Code Farming
Sep 11, 2026 · Backend Development

DDD-Driven Microservice Splitting: 3 Key Steps to Avoid Coupling Pitfalls

This article explains how Domain-Driven Design (DDD) guides microservice splitting through three steps: enforcing high cohesion and low coupling principles, dividing systems into core, supporting, and generic domains via bounded contexts, and using message queues for asynchronous event-driven decoupling, illustrated with an online food ordering example.

DDDMicroservicesbounded-context
0 likes · 8 min read
DDD-Driven Microservice Splitting: 3 Key Steps to Avoid Coupling Pitfalls
DevOps Operations Practice
DevOps Operations Practice
Sep 9, 2026 · Operations

Deploy Kafka 3.8.1 KRaft Cluster in 10 Minutes with Docker Compose

This guide walks through deploying a three-node Kafka 3.8.1 cluster using KRaft mode and Docker Compose, covering machine preparation, kernel tuning, cluster ID generation, node-specific configuration, startup, and verification steps including topic creation and message production/consumption.

Cluster SetupDockerDocker Compose
0 likes · 9 min read
Deploy Kafka 3.8.1 KRaft Cluster in 10 Minutes with Docker Compose
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 4, 2026 · Backend Development

10 Message Queue Patterns for Spring Boot: Decoupling, Async, Traffic Shaping & More

This article details 10 practical message queue scenarios for Spring Boot microservices, covering system decoupling, asynchronous processing, traffic shaping for flash sales, data synchronization, centralized logging, broadcast configuration updates, ordered message processing, delayed messages for timeouts, retry mechanisms with dead-letter queues, and transactional messaging for distributed consistency, with code examples for RabbitMQ, Kafka, and RocketMQ.

KafkaMicroservicesRabbitMQ
0 likes · 25 min read
10 Message Queue Patterns for Spring Boot: Decoupling, Async, Traffic Shaping & More
LuTiao Programming
LuTiao Programming
Sep 3, 2026 · Backend Development

Kafka 4.2 Share Groups: Can Kafka Replace RabbitMQ for Task Queues?

The author tests Kafka 4.2 Share Groups (Kafka Queues) by migrating a report-generation task queue from RabbitMQ, showing how Share Groups enable elastic consumer scaling beyond partition limits, manual acknowledgment modes (ACCEPT/RELEASE/REJECT/RENEW), and long-task handling with renew(), while noting RabbitMQ's routing strengths remain relevant.

KafkaKafka QueuesRabbitMQ
0 likes · 16 min read
Kafka 4.2 Share Groups: Can Kafka Replace RabbitMQ for Task Queues?
Alibaba Cloud Native
Alibaba Cloud Native
Sep 3, 2026 · Artificial Intelligence

Agent Rewrites Keep Coming: What Enterprises Must Retain for Lasting AI Value

The article argues that enterprises should invest in persistent business context rather than repeatedly rebuilding general Agent capabilities, using message-driven data integration and a unified semantic layer to make real-time, multi-source data reliably usable by Agents, illustrated by EventHouse's architecture.

AI InfrastructureAgent DevelopmentBusiness Context
0 likes · 28 min read
Agent Rewrites Keep Coming: What Enterprises Must Retain for Lasting AI Value
Code Farming
Code Farming
Sep 2, 2026 · Backend Development

Event Sourcing: Decouple Microservices with Domain Events

This article explains how event sourcing replaces synchronous call chains with domain events to decouple microservices, detailing the four core event elements, a three-step publish-subscribe flow using Spring Cloud Stream, and a practical template for implementation.

Domain EventsDomain-Driven DesignEvent Sourcing
0 likes · 6 min read
Event Sourcing: Decouple Microservices with Domain Events
Java Companion
Java Companion
Sep 1, 2026 · Backend Development

How RocketMQ’s LiteTopic Empowers Million-Scale AI Conversations

The article explains how RocketMQ 5.5.0 introduces the LiteTopic model to support AI workloads, detailing its lightweight two‑layer topic design, automatic creation, RocksDB indexing, event‑driven consumption, precise flow control, and provides step‑by‑step setup and code examples.

AIConsume SuspendLiteTopic
0 likes · 9 min read
How RocketMQ’s LiteTopic Empowers Million-Scale AI Conversations
samdeepthink
samdeepthink
Aug 25, 2026 · Backend Development

How RocketMQ Transactional Messages Ensure Data Consistency in Order‑Inventory Scenarios

The article explains how RocketMQ’s transactional message mechanism guarantees consistency between order creation and inventory deduction by using half‑messages, a local transaction callback, a second‑phase confirmation, and broker‑side timeout checks, while highlighting common pitfalls and best‑practice recommendations.

Distributed ConsistencyMicroservicesRocketMQ
0 likes · 9 min read
How RocketMQ Transactional Messages Ensure Data Consistency in Order‑Inventory Scenarios
Mike Chen Rui
Mike Chen Rui
Aug 19, 2026 · Backend Development

What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?

The article explains how flash‑sale systems differ from regular e‑commerce, outlines characteristic traffic spikes, and defines TPS ranges—100‑1,000, 1,000‑5,000, 5,000‑10,000, and 10,000‑50,000—that indicate low, medium, mature, and ultra‑high concurrency, while noting the architectural techniques needed to sustain tens of thousands of requests.

RedisTPSe-commerce
0 likes · 4 min read
What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?
Architecture Digest
Architecture Digest
Aug 17, 2026 · Backend Development

From a Naïve Scheduled Task to Scalable Delayed‑Task Solutions for 10M+ Orders

The article dissects a common interview question about automatically canceling unpaid orders, explains why a simple cron job fails at massive scale, and presents three robust designs—Redis expiration, Redis ZSet polling, and MQ/time‑wheel approaches—plus pitfalls and a ready‑to‑use answer template.

Delayed TaskRedisbackend architecture
0 likes · 11 min read
From a Naïve Scheduled Task to Scalable Delayed‑Task Solutions for 10M+ Orders
Ray's Galactic Tech
Ray's Galactic Tech
Aug 12, 2026 · Backend Development

Message Queue Showdown: When to Use Kafka, RabbitMQ, or Pulsar

This article dissects common MQ mis‑selections, categorises four message types, explains the five architectural roles of a message broker, compares Kafka, RabbitMQ and Pulsar on capabilities and trade‑offs, and provides a step‑by‑step selection guide with real‑world code snippets and best‑practice patterns.

KafkaOutbox PatternPulsar
0 likes · 26 min read
Message Queue Showdown: When to Use Kafka, RabbitMQ, or Pulsar
Java Tech Enthusiast
Java Tech Enthusiast
Aug 9, 2026 · Backend Development

Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second

This article explains how to replace traditional message queues with LMAX Disruptor in a Spring Boot application, covering its core concepts, step‑by‑step implementation, and a demo that demonstrates lock‑free, high‑throughput processing capable of handling six million orders per second.

DisruptorSpring Boothigh concurrency
0 likes · 10 min read
Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second
liandk
liandk
Aug 8, 2026 · Backend Development

Fixing MQ’s Four Major Issues: Loss, Duplication, Backlog, and Out‑of‑Order Messages

The article explains how to build a production‑grade MQ architecture by addressing the four critical pitfalls—message loss, duplicate consumption, backlog, and out‑of‑order delivery—through producer ACK retries, persistent storage, manual ACKs, idempotent business logic, dead‑letter queues, consumer scaling, and partitioned ordering.

MQdead letter queueidempotency
0 likes · 7 min read
Fixing MQ’s Four Major Issues: Loss, Duplication, Backlog, and Out‑of‑Order Messages
Cloud Architecture
Cloud Architecture
Aug 7, 2026 · Backend Development

Designing an Industrial‑Grade Message Queue for Tens of Millions of Orders

This article presents a step‑by‑step design of HermesMQ, an industrial‑grade message queue built from scratch to support ten‑million‑order traffic, covering storage as sequential logs, network architecture with Netty and Reactor, high‑availability replication, partition ordering, transaction messaging, back‑pressure, observability, and practical deployment guidelines.

High AvailabilityTransaction Messagingdistributed systems
0 likes · 45 min read
Designing an Industrial‑Grade Message Queue for Tens of Millions of Orders
Cloud Architecture
Cloud Architecture
Aug 7, 2026 · Backend Development

Building a Trillion‑Message Queue: Kafka‑Level Architecture and Implementation

This article explains why and how to build a Kafka‑grade message‑queue kernel from scratch, detailing functional and non‑functional goals, core design principles, storage layout, replication, consumer‑group coordination, performance optimizations, deployment on Kubernetes, and a step‑by‑step roadmap to production‑grade reliability.

Distributed LogKafkaRaft
0 likes · 40 min read
Building a Trillion‑Message Queue: Kafka‑Level Architecture and Implementation
Xike
Xike
Aug 5, 2026 · Backend Development

How to Automatically Cancel Unpaid Orders When They Timeout

The article explains a reliable, idempotent solution for automatically cancelling orders that remain unpaid after a configured deadline, covering data modeling, state transitions, trigger mechanisms using delayed messages or scans, handling race conditions with payment, and essential monitoring and pitfalls.

BackendRocketMQdistributed systems
0 likes · 17 min read
How to Automatically Cancel Unpaid Orders When They Timeout
CTO Full-Stack Academy
CTO Full-Stack Academy
Jul 30, 2026 · Operations

Common Cluster Issues and Practical Solutions for Apps, DBs, Caches, MQ, Files, and Search

The article enumerates typical problems encountered in application, database, cache, message‑queue, file‑server, and search clusters—such as session loss, uneven load, data inconsistency, and node failures—and provides concrete mitigation strategies like JWT authentication, distributed locks, health checks, NTP sync, and proper sharding.

CachingClusterHigh Availability
0 likes · 58 min read
Common Cluster Issues and Practical Solutions for Apps, DBs, Caches, MQ, Files, and Search
Code Farming
Code Farming
Jul 26, 2026 · Backend Development

How Is a Red Envelope System Designed for High‑Concurrency?

This article breaks down the end‑to‑end design of a high‑traffic red‑envelope service, covering its three‑stage lifecycle, a fair double‑mean allocation algorithm, the need to separate grabbing from settlement, and how Redis, Lua scripts, and message queues handle massive concurrent requests.

BackendRedisdistributed lock
0 likes · 7 min read
How Is a Red Envelope System Designed for High‑Concurrency?
Ray's Galactic Tech
Ray's Galactic Tech
Jul 23, 2026 · Backend Development

How to Keep Billions of Order States In Order with RocketMQ’s Ordered Messaging

The article explains why order‑status updates can become out‑of‑order in high‑traffic systems, how RocketMQ’s ordered‑message feature guarantees per‑key sequencing while highlighting its trade‑offs, and provides concrete producer and consumer implementations, failure handling, scaling, and deployment guidelines to ensure reliable, idempotent order processing.

MicroservicesOrdered MessagingRocketMQ
0 likes · 27 min read
How to Keep Billions of Order States In Order with RocketMQ’s Ordered Messaging
Alibaba Cloud Native
Alibaba Cloud Native
Jul 23, 2026 · Backend Development

How an Agent Collaboration Failure Revealed RocketMQ’s AI‑Era Upgrade

The article dissects a multi‑Agent workflow that stalls for minutes, exposing why traditional message queues cannot handle AI‑driven long‑running, stateful sessions and how RocketMQ’s 5.x LiteTopic, event‑driven pull, and Suspend consumption model redesign the communication paradigm for AI workloads.

AICloud NativeEvent-Driven Pull
0 likes · 13 min read
How an Agent Collaboration Failure Revealed RocketMQ’s AI‑Era Upgrade
Tencent Cloud Middleware
Tencent Cloud Middleware
Jul 23, 2026 · Backend Development

How TDMQ RocketMQ Lite Topic Keeps Millions of Channels Lightweight (Part 2)

This article dissects TDMQ RocketMQ's Lite Topic, explaining its two‑level topic model, automatic lifecycle, storage reuse, client‑level subscription management with Ready Event Sets, and the exclusive "latest‑connection‑wins" consumption mode that together enable millions of lightweight channels for AI‑native applications.

AI-native applicationsExclusive ConsumptionLite Topic
0 likes · 11 min read
How TDMQ RocketMQ Lite Topic Keeps Millions of Channels Lightweight (Part 2)
Code Farming
Code Farming
Jul 22, 2026 · Backend Development

Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests

To survive a million concurrent flash‑sale clicks, the article breaks down a production‑grade, five‑layer architecture—CDN, load balancer, API gateway, Redis/Lua stock control, message‑queue order processing, and a state‑machine fallback—that filters traffic early, uses atomic operations, and decouples writes to keep database load to just a few QPS.

LuaMySQLRedis
0 likes · 7 min read
Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests
IT Learning Made Simple
IT Learning Made Simple
Jul 21, 2026 · Fundamentals

Key Takeaways from 'Designing Large-Scale Distributed Systems'

This note distills the core engineering practices for building and operating large‑scale distributed systems, covering system definition, distributed vs single‑node trade‑offs, CAP theorem choices, consistency levels, transaction patterns, load‑balancing algorithms, cache strategies, message‑queue reliability, coordination services like ZooKeeper, and essential design principles.

CAP theoremCachingZooKeeper
0 likes · 11 min read
Key Takeaways from 'Designing Large-Scale Distributed Systems'
Java Tech Workshop
Java Tech Workshop
Jul 21, 2026 · Backend Development

A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature

The article explains how Spring’s built‑in @Async and TransactionalEventListener mechanisms provide a lightweight, zero‑dependency alternative to external message queues for local asynchronous processing, detailing their advantages, limitations, and production‑grade enhancements such as custom thread pools, dead‑letter persistence, and clustering strategies.

@AsyncSpringThread Pool
0 likes · 17 min read
A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature
Code Farming
Code Farming
Jul 20, 2026 · Backend Development

How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second

The article explains how using a message queue as a buffer, asynchronous processor, and decoupling layer enables flash‑sale systems to handle tens of thousands of orders per second, reducing database overload, cutting response time from 500 ms to 50 ms, and preventing cascade failures.

System Designasynchronous-processingdecoupling
0 likes · 5 min read
How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second
samdeepthink
samdeepthink
Jul 20, 2026 · Fundamentals

Good Architecture Means Cutting Components, Not Adding More

The article argues that seasoned developers improve system architecture by removing unnecessary components—such as redundant Redis caches or message queues—rather than continuously adding new ones, because each addition raises complexity and maintenance overhead, while simpler designs are easier to manage and evolve.

RedisSpringcomponent removal
0 likes · 3 min read
Good Architecture Means Cutting Components, Not Adding More
Cloud Architecture
Cloud Architecture
Jul 18, 2026 · Backend Development

RabbitMQ Idempotent Consumption: Keeping Duplicate Processing Within Business Limits

The article explains why RabbitMQ provides at‑least‑once delivery, how duplicate consumption arises in publish‑subscribe scenarios, and presents a step‑by‑step design—including deduplication keys, a deduplication table, transactional writes, proper ACK ordering, and a checklist of common pitfalls—to ensure idempotent processing stays within acceptable business tolerances.

Database TransactionRabbitMQSpring Boot
0 likes · 20 min read
RabbitMQ Idempotent Consumption: Keeping Duplicate Processing Within Business Limits
Ray's Galactic Tech
Ray's Galactic Tech
Jul 17, 2026 · Backend Development

Three Critical Guarantees for Message Queues: No Loss, No Duplicates, No Disorder – Deep Dive into Production‑Grade Solutions

This article dissects why modern systems must enforce three reliability guarantees—no message loss, no duplicate processing, and no out‑of‑order delivery—by examining real‑world order flows, outbox patterns, idempotent keys, partitioning strategies, consumer acknowledgments, and operational safeguards such as replay, dead‑letter handling, and monitoring.

KafkaOutbox Patterndistributed systems
0 likes · 28 min read
Three Critical Guarantees for Message Queues: No Loss, No Duplicates, No Disorder – Deep Dive into Production‑Grade Solutions
Java Backend Technology
Java Backend Technology
Jul 17, 2026 · Backend Development

How RocketMQ 5.5.0 Enables Asynchronous AI Agent Workloads with LiteTopic

The article explains why traditional synchronous calls block AI agents, introduces RocketMQ 5.5.0's LiteTopic designed for AI workloads, and demonstrates with Java code how to build a non‑blocking multi‑agent system, manage distributed session state, and intelligently schedule GPU resources.

AIDistributed Session ManagementLiteTopic
0 likes · 16 min read
How RocketMQ 5.5.0 Enables Asynchronous AI Agent Workloads with LiteTopic
dbaplus Community
dbaplus Community
Jul 15, 2026 · Backend Development

Why Are More Teams Switching from RabbitMQ to NATS?

The article compares RabbitMQ and NATS, outlining RabbitMQ's maturity and operational complexity versus NATS's lightweight, high‑performance, cloud‑native design, and explains when each solution is appropriate for modern microservice, edge, and AI‑driven architectures.

Cloud NativeJetStreamMicroservices
0 likes · 8 min read
Why Are More Teams Switching from RabbitMQ to NATS?
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine

The article dissects a proven trillion‑level counter architecture, tracing its evolution from a simple MySQL table through hash sharding, a full Redis migration, deep Redis memory optimizations, and hot‑cold separation, while detailing the trade‑offs and performance gains at each step.

Redis optimizationcounter architecturehigh concurrency
0 likes · 6 min read
Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine
YiSu Grain
YiSu Grain
Jul 7, 2026 · Fundamentals

Why You Don't Need to Send an SMS Immediately After an Order – Understanding Kafka and Message Queues

The article explains how using a message queue such as Kafka lets an order service return quickly by handling non‑critical tasks like SMS, points, and logging asynchronously, thereby improving latency, decoupling services, and smoothing traffic spikes while also covering Kafka's core concepts and trade‑offs.

KafkaPeak Shavingasynchronous-processing
0 likes · 11 min read
Why You Don't Need to Send an SMS Immediately After an Order – Understanding Kafka and Message Queues
Tencent Cloud Middleware
Tencent Cloud Middleware
Jul 7, 2026 · Cloud Native

Decoding AI Agent Collaboration: RocketMQ Lite Topic Makes Messaging as Easy as Creating a File

The article analyzes the communication challenges of AI‑native applications—async coordination, per‑session isolation, and millions of independent channels—and shows how RocketMQ Lite Topic solves them with lightweight, auto‑reclaimed topics that guarantee strict ordering, fault‑tolerant streaming, and seamless break‑resume handling.

AI-native applicationsAsynchronous MessagingLite Topic
0 likes · 15 min read
Decoding AI Agent Collaboration: RocketMQ Lite Topic Makes Messaging as Easy as Creating a File
Su San Talks Tech
Su San Talks Tech
Jul 7, 2026 · Backend Development

How to Choose Among Four Popular Message Queues?

This article compares Kafka, RocketMQ, RabbitMQ, and ActiveMQ, explaining their architectures, core concepts, strengths and weaknesses, and provides practical guidance on selecting the most suitable queue based on throughput, reliability, scalability, and use‑case requirements.

Backend DevelopmentKafkaRabbitMQ
0 likes · 20 min read
How to Choose Among Four Popular Message Queues?
Random Bulletin
Random Bulletin
Jul 3, 2026 · Operations

From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues

A bulk coupon‑sending job overwhelmed a million‑QPS system, revealing that message queues only buffer but do not shape traffic; the article dissects three failure points, compares leaky‑bucket and token‑bucket rate limiters, evaluates placement on producer, broker or consumer, and progresses from static limits to adaptive shaping with handling of throttled messages.

adaptive throttlingleaky-bucketmessage queue
0 likes · 18 min read
From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues
Random Bulletin
Random Bulletin
Jul 2, 2026 · Operations

From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems

A bulk coupon‑sending job overwhelmed a 10 M‑QPS system, revealing that message queues only buffer traffic; the article walks through why rate‑limiting (leaky vs token bucket) must be added at the producer, broker, or consumer, evolves from static thresholds to adaptive shaping, and discusses how to handle throttled messages.

adaptive throttlingleaky-bucketmessage queue
0 likes · 18 min read
From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 2, 2026 · Backend Development

Building High-Reliability Message-Driven Architecture with Spring Boot: Preventing Loss, Duplicates & Backlogs

This article details production-hardened patterns for building reliable message-driven systems with Spring Boot, covering MQ selection, producer confirmations, local message tables, manual acknowledgment, retry with backoff, dead-letter queues, idempotency strategies, backlog monitoring, ordered messaging, distributed tracing, and JVM/OS tuning parameters.

Backpressure HandlingJVM TuningReliability Patterns
0 likes · 20 min read
Building High-Reliability Message-Driven Architecture with Spring Boot: Preventing Loss, Duplicates & Backlogs
Cloud Architecture
Cloud Architecture
Jul 1, 2026 · Backend Development

8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads

The article examines eight practical ways to implement asynchronous programming—thread pools, CompletableFuture, Spring @Async, message queues, event‑driven architecture, reactive streams, the Actor model, and coroutines/virtual threads—explaining their core mechanisms, trade‑offs, production‑grade configurations, and when each should be chosen.

Asynchronous ProgrammingSpringconcurrency
0 likes · 53 min read
8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads
Random Bulletin
Random Bulletin
Jul 1, 2026 · Operations

Evolving Message Expiration for 10 Million QPS: From No TTL to Smart Policies

When a high‑traffic system processes billions of messages per day, stale “zombie” messages can corrupt business state; this article walks through the evolution from never‑expiring queues to uniform TTL, then per‑topic and per‑message TTL, and finally to smart, context‑aware expiration, detailing the engineering trade‑offs, implementation patterns, and operational checklist needed for reliable 10 M‑QPS message pipelines.

KafkaRocketMQdistributed systems
0 likes · 19 min read
Evolving Message Expiration for 10 Million QPS: From No TTL to Smart Policies
Su San Talks Tech
Su San Talks Tech
Jul 1, 2026 · Artificial Intelligence

How RocketMQ 5.5.0 Enables AI Workloads with LiteTopic

The article explains why AI tasks suffer from long‑lasting, blocking calls, and shows how Apache RocketMQ 5.5.0’s LiteTopic transforms synchronous multi‑agent workflows into asynchronous, non‑blocking pipelines, boosting throughput, preserving session state, and providing smart GPU scheduling.

AI IntegrationDistributed Session ManagementLiteTopic
0 likes · 15 min read
How RocketMQ 5.5.0 Enables AI Workloads with LiteTopic
Random Bulletin
Random Bulletin
Jun 30, 2026 · Operations

Preventing Message Queue Backlog at Ten‑Million QPS: From Reactive to Proactive

The article explains how a ten‑million‑QPS messaging system can shift from reactive fire‑fighting to proactive backlog prevention by using long‑, mid‑, and short‑term defense layers, capacity planning, predictive scaling, backpressure, and regular chaos engineering to eliminate user‑visible latency.

backlog preventionbackpressurecapacity-planning
0 likes · 19 min read
Preventing Message Queue Backlog at Ten‑Million QPS: From Reactive to Proactive
Random Bulletin
Random Bulletin
Jun 29, 2026 · Operations

Backlog Digestion at Ten‑Million QPS: From Adding Machines to Intelligent Scheduling

The article dissects how to handle massive message backlog in ten‑million‑QPS systems, explaining why simply adding consumer machines fails, and walks through six evolutionary stages—from manual scaling and auto‑scaling to traffic tiering, consumer‑side optimizations, dynamic strategies, and AI‑driven intelligent scheduling—while highlighting design trade‑offs, pitfalls, and practical tooling.

Operationsauto-scalingbacklog digestion
0 likes · 22 min read
Backlog Digestion at Ten‑Million QPS: From Adding Machines to Intelligent Scheduling
Random Bulletin
Random Bulletin
Jun 27, 2026 · Operations

Cross‑Data‑Center Replication at Ten‑Million QPS: From Async to Semi‑Sync and How to Choose

The article examines why cross‑datacenter replication must evolve from simple asynchronous copying to semi‑synchronous and layered strategies at the ten‑million‑QPS scale, detailing latency, RPO, bandwidth costs, failover complexities, and practical selection guidelines for each business tier.

asynchronous replicationbandwidth optimizationcross-datacenter replication
0 likes · 17 min read
Cross‑Data‑Center Replication at Ten‑Million QPS: From Async to Semi‑Sync and How to Choose
Random Bulletin
Random Bulletin
Jun 26, 2026 · Operations

Message Duplication Is Inevitable: Building a Multi‑Layer Idempotency Middleware for Ten‑Million QPS

Message queues guarantee at‑least‑once delivery, making duplicate messages a normal feature; the article examines a real coupon‑distribution incident, critiques business‑level idempotency approaches, and outlines a layered platform‑wide middleware design—including unique keys, state machines, storage choices, and TTL strategies—to achieve reliable processing at ten‑million QPS scale.

distributed systemshigh QPSidempotency
0 likes · 19 min read
Message Duplication Is Inevitable: Building a Multi‑Layer Idempotency Middleware for Ten‑Million QPS
Random Bulletin
Random Bulletin
Jun 25, 2026 · Operations

Scaling Message Queues to 10M QPS: From Downtime to Seamless Online Expansion

At the 10‑million‑QPS scale, expanding a message‑queue cluster no longer hinges on simply adding brokers; it requires coordinated online upgrades of metadata, data migration with dynamic throttling, cooperative consumer rebalance, shadow‑traffic warm‑up, and rollback snapshots, making the act of adding machines the hardest part.

10M QPSRebalancedistributed systems
0 likes · 27 min read
Scaling Message Queues to 10M QPS: From Downtime to Seamless Online Expansion
Niu Liu
Niu Liu
Jun 25, 2026 · Backend Development

Don’t Mix Them Up: When to Use RPC, MQ, or Offline Scripts

The article breaks down three fundamental mechanisms—synchronous RPC, asynchronous MQ, and offline scripts—by comparing their lifecycles, IO models, bottlenecks, and consistency guarantees, and provides a concrete decision framework for choosing the right tool for different business scenarios.

Batch ProcessingMicroservicesRPC
0 likes · 12 min read
Don’t Mix Them Up: When to Use RPC, MQ, or Offline Scripts
Cloud Architecture
Cloud Architecture
Jun 24, 2026 · Backend Development

Four Levels of Concurrency Control: Optimistic Locks to Message Queues for Million‑QPS

High‑concurrency systems must go beyond simple locking; the article breaks down four progressive strategies—optimistic locking, database pessimistic locking, Redis distributed locks, and finally message‑queue serialization—explaining their trade‑offs, implementation details, pitfalls, and how to combine them into a layered architecture that sustains million‑QPS workloads with consistency, throughput, and recoverability.

Optimistic LockPessimistic LockRedis Lock
0 likes · 32 min read
Four Levels of Concurrency Control: Optimistic Locks to Message Queues for Million‑QPS
Java Architect Handbook
Java Architect Handbook
Jun 24, 2026 · Backend Development

Auto‑Cancel Unpaid Orders After 30 Minutes with RabbitMQ: TTL + DLX vs Delayed Message Plugin

The article explains two ways to implement a 30‑minute order auto‑cancellation in RabbitMQ—using the classic TTL + dead‑letter exchange pattern (with its head‑blocking pitfall) and the newer delayed‑message‑exchange plugin—provides Spring Boot configuration examples, compares their trade‑offs, and offers interview tips on when to choose each solution.

Delayed Message PluginRabbitMQSpring Boot
0 likes · 12 min read
Auto‑Cancel Unpaid Orders After 30 Minutes with RabbitMQ: TTL + DLX vs Delayed Message Plugin
Tinker Programmer
Tinker Programmer
Jun 24, 2026 · Fundamentals

Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples

This article walks through the three core behavioral design patterns—Strategy, Observer, and Chain of Responsibility—explaining their intent, showing problematic anti‑patterns, providing step‑by‑step Spring and MQ code implementations, mapping them to real‑world frameworks, and offering interview‑style comparison questions to solidify understanding.

Chain of ResponsibilityDesign PatternsObserver Pattern
0 likes · 19 min read
Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples
Random Bulletin
Random Bulletin
Jun 23, 2026 · Backend Development

Choosing the Right Replication Factor for 10M QPS Message Queues: From Dual to Multi‑Replica

The article walks through why a single replica is insufficient for million‑scale message queues, explains the latency and data‑loss trade‑offs of dual‑replica sync and async modes, shows how three‑replica majority voting becomes the sweet spot, and then details the engineering considerations for scaling to five or more replicas across availability zones and regions.

AZ awarenessHigh AvailabilityKafka
0 likes · 18 min read
Choosing the Right Replication Factor for 10M QPS Message Queues: From Dual to Multi‑Replica
ZhiKe AI
ZhiKe AI
Jun 22, 2026 · Fundamentals

Message Queues: Power When Correct, Disaster When Wrong – 3 Scenarios & Tips

The article explains how message queues can dramatically improve response time, decouple services, and smooth traffic spikes, outlines seven advantages and eight drawbacks, and provides concrete guidelines on when to adopt them, how to prevent loss, duplication, and ordering issues, and how to ensure end‑to‑end reliability.

KafkaRabbitMQSystem Decoupling
0 likes · 15 min read
Message Queues: Power When Correct, Disaster When Wrong – 3 Scenarios & Tips
ZhiKe AI
ZhiKe AI
Jun 21, 2026 · Databases

From ACID to BASE: Picking the Best of 6 Distributed Transaction Strategies

The article explains why ACID guarantees break down in distributed systems, introduces the BASE and CAP trade‑offs, then details six concrete transaction solutions—2PC, 3PC, TCC, Saga, local message tables, and reliable messages—highlighting their processes, drawbacks, and a decision framework for selecting the right approach.

2PC3PCACID
0 likes · 19 min read
From ACID to BASE: Picking the Best of 6 Distributed Transaction Strategies
Code Farming
Code Farming
Jun 20, 2026 · Backend Development

How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing

The article breaks down a complete flash‑sale system into four phases and explains how Redis distributed locks, CDN static pages, Nginx rate limiting, message‑queue peak shaving, and sharding together prevent overselling, crashes, and lost orders even when traffic surges dozens of times.

NginxRedisflash sale
0 likes · 6 min read
How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing
Code Farming
Code Farming
Jun 19, 2026 · Backend Development

Nail Distributed Transaction Consistency Questions in Interviews with This Full‑Score Answer

The article explains why reciting the 2PC protocol fails in real‑world interviews, then walks through the two dominant solutions—two‑phase commit and MQ‑based eventual consistency—detailing their mechanisms, trade‑offs, and a concrete interview response template that showcases practical experience and theoretical depth.

Distributed TransactionsMicroserviceseventual consistency
0 likes · 6 min read
Nail Distributed Transaction Consistency Questions in Interviews with This Full‑Score Answer
Cloud Architecture
Cloud Architecture
Jun 19, 2026 · Backend Development

RabbitMQ vs RocketMQ Delayed Messaging Deep Dive: Core Principles, Architecture Limits, and Production‑Ready Implementation

This article analyses why delayed messaging is a critical system bottleneck, compares RabbitMQ and RocketMQ implementations—including TTL+DLX, delayed‑plugin, fixed‑level and timestamp‑based approaches—provides detailed architectural diagrams, code samples, scaling strategies, operational checklists, and guidance on choosing the right solution for production workloads.

Delayed MessagingOutbox PatternRabbitMQ
0 likes · 39 min read
RabbitMQ vs RocketMQ Delayed Messaging Deep Dive: Core Principles, Architecture Limits, and Production‑Ready Implementation
Random Bulletin
Random Bulletin
Jun 18, 2026 · Operations

Zero Message Loss at 10M QPS: From Best‑Effort to Proven Guarantees

The article dissects why message loss is an end‑to‑end engineering challenge across production, broker, and consumer stages, presents real‑world failure cases at ten‑million QPS, and outlines concrete strategies—ack loops, outbox tables, broker replication settings, consumer handling rules, observability, reconciliation, and SLA‑driven compensation—to evolve from best‑effort to provable, recoverable reliability.

ObservabilityOutbox PatternSLA
0 likes · 17 min read
Zero Message Loss at 10M QPS: From Best‑Effort to Proven Guarantees
Architecture & Thinking
Architecture & Thinking
Jun 18, 2026 · Backend Development

How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide

This article dissects the evolution of a flash‑sale system from a simple monolithic controller to a cloud‑native, micro‑service architecture that can handle over one million requests per second, detailing traffic‑shaping, multi‑level caching, async processing, and inventory‑consistency techniques.

CachingDistributed ArchitectureKubernetes
0 likes · 18 min read
How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide
Random Bulletin
Random Bulletin
Jun 16, 2026 · Backend Development

Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures

The article explains why consumer‑side rate limiting is essential in million‑QPS systems, detailing how unchecked consumers can overwhelm downstream services, and presents practical strategies—including pause/resume, token‑bucket algorithms, adaptive thresholds, and global coordination—to safely throttle consumption without dropping messages.

Kafkaconsumer optimizationdistributed systems
0 likes · 16 min read
Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures
Random Bulletin
Random Bulletin
Jun 15, 2026 · Backend Development

From Auto to Manual: Mastering Consumer Offsets for Ten‑Million QPS Systems

The article examines a real payment loss incident caused by Kafka's default automatic offset commit, explains why automatic commits become a hidden trap at high traffic, and provides a step‑by‑step guide to switching to manual commits with async‑first, sync‑fallback, idempotency, dead‑letter handling, batch strategies, and concurrency controls for reliable ten‑million QPS consumption.

Kafkadead-letter queuehigh throughput
0 likes · 15 min read
From Auto to Manual: Mastering Consumer Offsets for Ten‑Million QPS Systems
Cloud Architecture
Cloud Architecture
Jun 15, 2026 · Backend Development

Trillion‑Message Engine Showdown: RabbitMQ vs Kafka Architecture, Performance and Cloud‑Native Pitfalls

An experienced architect compares RabbitMQ and Kafka across core protocols, storage, replication, consumption semantics, and real‑world production designs, offering Java 17/Spring Boot code, cloud‑native deployment tips, observability, and a decision framework that matches messaging patterns to business requirements.

Cloud NativeEvent StreamingKafka
0 likes · 45 min read
Trillion‑Message Engine Showdown: RabbitMQ vs Kafka Architecture, Performance and Cloud‑Native Pitfalls
Random Bulletin
Random Bulletin
Jun 14, 2026 · Backend Development

Scaling to Millions of QPS: How Batch Consumption Beats Single-Message Processing

The article explains why single‑message consumption stalls under high QPS due to fixed per‑message overhead, and how merging pull, processing, and commit into batch operations dramatically boosts throughput while introducing trade‑offs in latency, memory, and failure handling, with practical guidelines for batch size selection and dynamic tuning.

KafkaPerformance Optimizationbatch consumption
0 likes · 16 min read
Scaling to Millions of QPS: How Batch Consumption Beats Single-Message Processing
Random Bulletin
Random Bulletin
Jun 13, 2026 · Backend Development

Scaling Consumer Parallelism: From Single‑Thread to Multi‑Thread for Ten‑Million QPS

The article analyzes why single‑threaded message consumption hits processing, I/O/CPU mismatch, and fault‑tolerance limits, then walks through a step‑by‑step evolution—pull/worker split, key‑based routing, sliding‑window offset commits, backpressure, and multi‑layer parallelism—to achieve stable ten‑million‑QPS throughput.

backpressureconsumer parallelismhigh throughput
0 likes · 22 min read
Scaling Consumer Parallelism: From Single‑Thread to Multi‑Thread for Ten‑Million QPS
Subtle Storm
Subtle Storm
Jun 6, 2026 · Backend Development

Flash Sale Architecture: A Complete Blueprint for High‑Traffic Systems

To handle the massive, short‑lived traffic of flash‑sale events, architects must combine static content delivery, Redis‑based inventory pre‑loading, asynchronous order processing, distributed rate‑limiting, stateless services, Kubernetes auto‑scaling, graceful degradation, circuit breaking, and robust monitoring to ensure reliability and prevent overload.

Circuit BreakingKubernetesRedis
0 likes · 8 min read
Flash Sale Architecture: A Complete Blueprint for High‑Traffic Systems
Cloud Architecture
Cloud Architecture
Jun 5, 2026 · Backend Development

RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency

This article explains why a RocketMQ producer is more than a simple send API, detailing its role in system throughput, consistency and fault isolation, and walks through sending principles, thread models, high‑concurrency design, retry strategies, back‑pressure mechanisms, outbox integration and production‑grade monitoring.

OutboxRocketMQSpring Boot
0 likes · 54 min read
RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency
Random Bulletin
Random Bulletin
Jun 2, 2026 · Backend Development

Queue Selection at Ten‑Million QPS: From General‑Purpose to Specialized Queues

In systems handling ten‑million QPS, generic message queues like Kafka hit scalability and latency limits, so the article breaks down a three‑question framework—loss tolerance, latency sensitivity, and ordering needs—to match five specialized queue types and guide a transition from a single‑queue approach to a queue matrix.

KafkaRocketMQdistributed systems
0 likes · 18 min read
Queue Selection at Ten‑Million QPS: From General‑Purpose to Specialized Queues
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.

DelayQueueRabbitMQRedis
0 likes · 7 min read
Why Using Redis Expiration Listener for Order Cancellation Is a Bad Idea
Architecture & Thinking
Architecture & Thinking
May 20, 2026 · Operations

Six‑Step Emergency Plan to Detect, Recover, and Eliminate Message Backlog

In distributed systems, message‑queue backlogs can cripple core services; this article breaks down a six‑step emergency workflow—from alert detection and throttling to temporary scaling, root‑cause analysis, targeted fixes, and final validation—plus long‑term architectural and monitoring strategies, illustrated with real‑world cases and Java code samples.

BacklogOperationsRabbitMQ
0 likes · 21 min read
Six‑Step Emergency Plan to Detect, Recover, and Eliminate Message Backlog
Su San Talks Tech
Su San Talks Tech
May 19, 2026 · Interview Experience

Designing a Hundred‑Billion‑Scale Message Queue: A ByteDance Interview Walkthrough

This article walks through the interview question of designing a message queue that handles billions of messages daily and peaks at millions of QPS, covering traffic calculations, core roles, storage and throughput techniques, scalability, high availability, observability, framework comparisons, a real‑world case study, and key follow‑up interview topics.

KafkaPulsarRocketMQ
0 likes · 12 min read
Designing a Hundred‑Billion‑Scale Message Queue: A ByteDance Interview Walkthrough
Cloud Architecture
Cloud Architecture
May 15, 2026 · Backend Development

Production‑Grade IM Architecture with MQTT over RabbitMQ: Principles & Practices

This article analyses why MQTT over RabbitMQ is a better foundation than a custom WebSocket service for large‑scale instant‑messaging systems, detailing connection management, message routing, session handling, QoS, retained and will messages, topic design, Go client implementation, bridge service logic, scaling challenges, monitoring, and migration road‑maps.

GoIMKubernetes
0 likes · 40 min read
Production‑Grade IM Architecture with MQTT over RabbitMQ: Principles & Practices
Linyb Geek Road
Linyb Geek Road
May 15, 2026 · Backend Development

Idempotency in Practice: Handling the Same Key with Different Parameters

The article explains why simple key‑based idempotency fails when a second request carries different parameters, and demonstrates how to use database row locks, request fingerprinting, state machines, and explicit error handling to guarantee safe, non‑duplicate execution in payment‑critical APIs.

API Designdatabase lockingdistributed systems
0 likes · 13 min read
Idempotency in Practice: Handling the Same Key with Different Parameters
samdeepthink
samdeepthink
May 8, 2026 · Backend Development

Understanding RocketMQ’s Three Reliability Checkpoints

The article breaks down RocketMQ’s end‑to‑end reliability design into three checkpoints—producer to broker, broker persistence, and consumer acknowledgment—explaining each mechanism, configuration options, common pitfalls, and practical recommendations for production deployments.

ConsumerReplicationRocketMQ
0 likes · 16 min read
Understanding RocketMQ’s Three Reliability Checkpoints
dbaplus Community
dbaplus Community
May 6, 2026 · Backend Development

Why Scheduled Tasks Fail for Million‑Scale Order Cancellation and How Redis Solves It

The article dissects a common interview question about automatically canceling unpaid orders after 30 minutes, explains why naïve cron‑based scans are unsuitable for tens of millions of rows, and presents three progressively robust solutions using Redis expiration, Redis ZSet polling, and message‑queue or time‑wheel architectures.

Delayed TaskRedisZset
0 likes · 10 min read
Why Scheduled Tasks Fail for Million‑Scale Order Cancellation and How Redis Solves It
Lobster Programming
Lobster Programming
May 6, 2026 · Backend Development

How to Choose the Right MQ: RabbitMQ vs RocketMQ vs Kafka

This article compares RabbitMQ, RocketMQ, and Kafka on throughput, latency, scalability, and reliability, outlining each system's core features and recommending suitable scenarios such as reliable messaging, high‑performance streaming, and large‑scale real‑time data processing.

KafkaRabbitMQRocketMQ
0 likes · 6 min read
How to Choose the Right MQ: RabbitMQ vs RocketMQ vs Kafka
Architecture & Thinking
Architecture & Thinking
Apr 30, 2026 · Cloud Native

How RocketMQ 5.0’s New Proxy Layer Enables Compute‑Storage Separation and Cloud‑Native Scaling

RocketMQ 5.0 replaces the monolithic Broker with a stateless Proxy layer that decouples compute from storage, solves scalability, multi‑protocol and cloud‑native adaptation challenges, and is demonstrated through detailed architecture comparisons, Java code samples, and two real‑world IoT and finance case studies showing significant performance and cost benefits.

Cloud NativeCompute-Storage SeparationMulti-Protocol
0 likes · 20 min read
How RocketMQ 5.0’s New Proxy Layer Enables Compute‑Storage Separation and Cloud‑Native Scaling
Java Tech Workshop
Java Tech Workshop
Apr 29, 2026 · Backend Development

How to Diagnose and Scale SpringBoot Message Backlog with Monitoring

The article explains why message backlog occurs in SpringBoot applications, outlines systematic troubleshooting steps, proposes comprehensive monitoring across producer, broker, and consumer layers, and presents scaling tactics such as instance expansion, concurrency tuning, batch consumption, and long‑term capacity planning.

BacklogKafkaRabbitMQ
0 likes · 16 min read
How to Diagnose and Scale SpringBoot Message Backlog with Monitoring
IoT Full-Stack Technology
IoT Full-Stack Technology
Apr 29, 2026 · Databases

16 Practical Redis Use Cases You Should Know

This article walks through sixteen common Redis scenarios—including caching hot data, sharing state across services, implementing distributed locks, generating global IDs, counting events, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tagging, product filtering, and leaderboards—each illustrated with concrete commands and code snippets.

BitmapsCachingLeaderboard
0 likes · 9 min read
16 Practical Redis Use Cases You Should Know
IoT Full-Stack Technology
IoT Full-Stack Technology
Apr 29, 2026 · Databases

10+ Practical Redis Use Cases You Can Implement Today

This article walks through more than ten common Redis scenarios—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/fan relationships, and ranking—showing concrete command examples and code snippets for each.

BitmapCachingFollow System
0 likes · 9 min read
10+ Practical Redis Use Cases You Can Implement Today
Java Architect Handbook
Java Architect Handbook
Apr 28, 2026 · Backend Development

SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency

This article explains why Disruptor—a lock‑free, high‑throughput Java queue from LMAX—was chosen over traditional brokers, details its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step SpringBoot demo that can handle up to six million orders per second without pressure.

DisruptorSpringBoothigh concurrency
0 likes · 13 min read
SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency
Java Tech Workshop
Java Tech Workshop
Apr 27, 2026 · Backend Development

How to Integrate Kafka with SpringBoot for High‑Performance Messaging

This article walks through Kafka’s core architecture, explains why it achieves massive throughput, and provides a step‑by‑step SpringBoot integration—including environment setup, Maven dependencies, configuration, producer and consumer code, advanced features like transactions and dead‑letter queues, plus performance monitoring and tuning tips.

ConsumerKafkaSpringBoot
0 likes · 11 min read
How to Integrate Kafka with SpringBoot for High‑Performance Messaging
Java Tech Workshop
Java Tech Workshop
Apr 26, 2026 · Backend Development

Integrating Spring Boot with RocketMQ for Message Production and Consumption

This tutorial explains why RocketMQ is chosen for high‑throughput messaging, outlines its core components and typical scenarios, guides environment setup via Docker or local installation, shows Maven integration, provides Spring Boot configuration, and presents complete producer and consumer code with testing steps, extensions for sync/async messages, and common troubleshooting tips.

ConsumerDockerMaven
0 likes · 16 min read
Integrating Spring Boot with RocketMQ for Message Production and Consumption
DevOps Coach
DevOps Coach
Apr 26, 2026 · Backend Development

Forget Kafka: A Lightweight Go Queue Achieves 2 Million Messages per Second

The article analyzes how replacing Kafka with a simple in‑memory Go queue reduced architectural complexity, boosted throughput from 240‑330 K to 1.8‑2.0 M messages per second, and clarified debugging, while still acknowledging scenarios where Kafka remains the better choice.

Backend PerformanceGoIn‑Memory Ring Buffer
0 likes · 8 min read
Forget Kafka: A Lightweight Go Queue Achieves 2 Million Messages per Second
Java Tech Workshop
Java Tech Workshop
Apr 26, 2026 · Backend Development

Getting Started with SpringBoot Integration of RabbitMQ

This article explains why RabbitMQ is essential for distributed systems, outlines its core functions and typical scenarios, and provides step‑by‑step instructions for setting up Docker or local installations, adding Maven dependencies, configuring SpringBoot, and implementing Direct, Fanout, and Topic exchange patterns with code examples and troubleshooting tips.

Direct ExchangeTopic Exchangefanout exchange
0 likes · 20 min read
Getting Started with SpringBoot Integration of RabbitMQ
Java Architect Handbook
Java Architect Handbook
Apr 23, 2026 · Interview Experience

Meituan Second Interview: Solving High RocketMQ Consumption Latency in Production

During a Meituan second-round interview, the candidate explains how to diagnose and resolve high RocketMQ consumption latency in production, outlining a three‑step approach—stop the bleeding, recover service, and cure the root cause—through consumer scaling, message forwarding, logic optimization, concurrency tuning, queue expansion, and monitoring.

Consumer LagRocketMQinterview preparation
0 likes · 14 min read
Meituan Second Interview: Solving High RocketMQ Consumption Latency in Production
Tencent Cloud Middleware
Tencent Cloud Middleware
Apr 22, 2026 · Backend Development

How TDMQ Pulsar Scales Million-Message Delayed Queues with Multi-Level Time Wheels

The article analyzes why large‑scale delayed messaging is needed, identifies the bottlenecks of the Apache Pulsar community solution, and explains TDMQ Pulsar's three‑step redesign—hierarchical time wheels, expiration re‑push, and immutable message IDs—that together enable stable million‑message delayed queues with controlled memory and minute‑level hole impact.

Apache PulsarDelayed MessagingTDMQ
0 likes · 8 min read
How TDMQ Pulsar Scales Million-Message Delayed Queues with Multi-Level Time Wheels
java1234
java1234
Apr 18, 2026 · Backend Development

Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers

This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.

BitmapGEOLeaderboard
0 likes · 21 min read
Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers
Java Architect Handbook
Java Architect Handbook
Apr 14, 2026 · Backend Development

Why RocketMQ Beats Kafka and RabbitMQ in Java Interviews: 6 Core Advantages

This article breaks down the interview focus points for messaging middleware, explains RocketMQ's "Three High and One Rich" advantages—high throughput, reliability, consistency, and rich features—compares it with Kafka and RabbitMQ, presents six detailed reasons with code samples, a selection decision tree, common interview variants, memory mnemonics, and a concise conclusion for Java developers.

Delayed MessageJava InterviewMessage reliability
0 likes · 15 min read
Why RocketMQ Beats Kafka and RabbitMQ in Java Interviews: 6 Core Advantages