Skip to content
Tagged articles

Message Queue

500 articles · Page 1 of 5
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 18, 2026 · Backend Development

Message Queues Explained: Principles, Architecture & Selection Guide

This article comprehensively explains message queue fundamentals including decoupling, async communication, reliability, and buffering; details architecture roles, queue types, persistence, acknowledgment, and protocols; compares ActiveMQ, RabbitMQ, Kafka, RocketMQ, and Pulsar with performance metrics; and provides selection guidance for e-commerce, finance, and big data scenarios.

ActiveMQKafkaMQ
0 likes · 8 min read
Message Queues Explained: Principles, Architecture & Selection Guide
Java Tech Enthusiast
Java Tech Enthusiast
Nov 13, 2026 · Backend Development

SpringBoot RabbitMQ/RocketMQ Integration: Reliable Delivery, Idempotent Consumption & Ordering Guarantees

A comprehensive guide covering message queue reliability patterns using SpringBoot with RabbitMQ and RocketMQ, including a real production incident analysis, core concepts, complete code implementation for reliable delivery, idempotent consumption with Redis SET NX, ordered processing, dead letter queues, and production-ready configurations.

Dead Letter QueueIdempotent ConsumptionMessage Queue
0 likes · 33 min read
SpringBoot RabbitMQ/RocketMQ Integration: Reliable Delivery, Idempotent Consumption & Ordering Guarantees
Architect's Guide
Architect's Guide
Oct 25, 2026 · Backend Development

8 Java Asynchronous Implementation Patterns for High Performance

This article explores eight ways to implement asynchronous programming in Java, including Thread, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture, with code examples and trade-offs for each approach.

Asynchronous ProgrammingCompletableFutureFuture
0 likes · 14 min read
8 Java Asynchronous Implementation Patterns for High Performance
Alibaba Cloud Native
Alibaba Cloud Native
Oct 22, 2026 · Cloud Native

MCP Task State Storage: RocketMQ LiteTopic as Per-Task Ledger

This article explains how RocketMQ LiteTopic solves the task state persistence problem for stateless MCP services by assigning each task a dedicated message channel that acts as an ordered, durable ledger, enabling reliable task tracking, automatic retries, and seamless replica failover without violating the protocol's stateless requirement.

AI AgentLiteTopicMCP
0 likes · 11 min read
MCP Task State Storage: RocketMQ LiteTopic as Per-Task Ledger
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.

Message QueueRediscache protection
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 29, 2026 · Backend Development

10 System Design Questions That Decide Big Tech Interview Success

This article dissects 10 high-frequency system design questions — seckill, short URL, distributed ID, delayed tasks, leaderboard, real-time push, short-video feed, sharding, rate limiting, and config center — with architecture diagrams, core code, and comparative solutions for each.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 73 min read
10 System Design Questions That Decide Big Tech Interview Success
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
Niu Liu
Niu Liu
Sep 25, 2026 · Backend Development

Exactly Once: What It Guarantees, Why Payments Double-Charge, and How to Fix It

This article explains that Exactly Once semantics in message queues like Kafka only guarantee exactly-once processing within the messaging system's transaction boundary, not for external side effects like payment APIs, and provides practical patterns using database unique constraints, idempotency keys, and timeout handling to achieve true end-to-end exactly-once behavior.

IdempotencyKafkaMessage Queue
0 likes · 9 min read
Exactly Once: What It Guarantees, Why Payments Double-Charge, and How to Fix It
Code Farmer Manor Chronicle
Code Farmer Manor Chronicle
Sep 25, 2026 · Backend Development

RabbitMQ Basics: Message Flow, Four Exchanges, Spring Boot Integration & Reliability

This tutorial explains RabbitMQ core concepts including message routing via exchanges and queues, details four exchange types (Direct, Fanout, Topic, Headers), provides Spring Boot integration code examples, covers reliability patterns like publisher confirms and manual acknowledgments, and lists common pitfalls with solutions.

AMQPDead Letter QueueExchange Types
0 likes · 12 min read
RabbitMQ Basics: Message Flow, Four Exchanges, Spring Boot Integration & Reliability
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.

Distributed SystemsKafkaMQ
0 likes · 14 min read
MQ Production Failure Troubleshooting: Message Loss, Duplicates, Backlog & Dead Letters
Niu Liu
Niu Liu
Sep 23, 2026 · Backend Development

Ordered Messages Aren't Enough: Preventing State Regressions with Versioning and State Machines

The article explains why message ordering alone fails to prevent business state regressions, detailing how version gaps and unordered consumption cause issues, and presents solutions using event versioning, state machines, and proper Kafka/RocketMQ configuration to ensure correct order processing per order ID while allowing parallelism across orders.

Distributed SystemsEvent VersioningKafka
0 likes · 10 min read
Ordered Messages Aren't Enough: Preventing State Regressions with Versioning and State Machines
samdeepthink
samdeepthink
Sep 23, 2026 · Backend Development

RabbitMQ Livelock: Emergency Fixes for Message Re-delivery Loops

The article explains livelock using a RabbitMQ incident where unacknowledged messages cause endless re-delivery, and describes two production fixes: immediate try-catch with ACK to stop the loop, then bug fix; and a configurable "empty consumption" switch to discard messages when replay is possible.

ConcurrencyMessage QueueRabbitMQ
0 likes · 6 min read
RabbitMQ Livelock: Emergency Fixes for Message Re-delivery Loops
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.

FTS5JSONMessage Queue
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.

Distributed SystemsIdempotencyMessage 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.

IdempotencyMessage QueueRetry Pattern
0 likes · 24 min read
Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 15, 2026 · Backend Development

RocketMQ Interview Deep Dive: 8 Core Topics from Architecture to Message Backlog

This comprehensive guide covers eight critical RocketMQ interview topics including architecture design, CommitLog storage, message sending/consumption modes, transaction messages, reliability mechanisms, duplicate consumption handling, and message backlog solutions with production-grade troubleshooting steps.

Distributed SystemsHigh AvailabilityIdempotency
0 likes · 40 min read
RocketMQ Interview Deep Dive: 8 Core Topics from Architecture to Message Backlog
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 DeploymentDead Letter QueueMessage Queue
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.

Bounded ContextDDDMessage Queue
0 likes · 8 min read
DDD-Driven Microservice Splitting: 3 Key Steps to Avoid Coupling Pitfalls
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.

Asynchronous ProcessingDistributed SystemsKafka
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 QueuesMessage Queue
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 DevelopmentEventHouse
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.

DecouplingEvent StormingMessage Queue
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 ConsistencyMessage QueueRocketMQ
0 likes · 9 min read
How RocketMQ Transactional Messages Ensure Data Consistency in Order‑Inventory Scenarios
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 20, 2026 · Backend Development

Microservice Idempotency: 7 Production Patterns to Eliminate Duplicate Orders & Payments

This article presents seven production-ready idempotency patterns for microservices — frontend debounce, token mechanism, database unique indexes, state machine validation, Redis caching, MQ consumer deduplication, and distributed locks — organized as a layered defense from frontend to database, with code examples and a real duplicate-payment incident analysis.

Distributed SystemsIdempotencyMessage Queue
0 likes · 11 min read
Microservice Idempotency: 7 Production Patterns to Eliminate Duplicate Orders & Payments
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.

Message QueueRedisScaling
0 likes · 4 min read
What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 18, 2026 · Backend Development

Local Message Tables: Production-Ready Microservice Async Consistency Solution

This article presents the local message table pattern as a lightweight, production-ready solution for achieving eventual consistency in microservice architectures, covering database schema design, transactional message persistence, scheduled retry mechanisms, idempotent consumption, and real-world incident resolution compared to heavier alternatives like Seata and TCC.

IdempotencyMessage Queuedatabase design
0 likes · 11 min read
Local Message Tables: Production-Ready Microservice Async Consistency Solution
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 17, 2026 · Backend Development

RabbitMQ vs Kafka vs RocketMQ: Complete MQ Selection Guide with Code & Interview Answers

This article provides a comprehensive comparison of RabbitMQ, Kafka, and RocketMQ across core features, performance, and use cases, with production-ready code for transactional messaging, idempotent consumption, and zero-loss configurations, plus solutions for seven common production pitfalls and interview answer templates.

Distributed SystemsIdempotencyKafka
0 likes · 36 min read
RabbitMQ vs Kafka vs RocketMQ: Complete MQ Selection Guide with Code & Interview Answers
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.

Backend ArchitectureDelayed TaskDistributed Systems
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.

KafkaMessage QueueOutbox Pattern
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.

DisruptorJavaMessage Queue
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.

Dead Letter QueueIdempotencyMQ
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.

Distributed SystemsHigh AvailabilityJava
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.

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

Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns

This article details a production-ready event-driven architecture for DDD microservices, covering the complete domain event flow, local event table for message loss prevention, three idempotency patterns for duplicate consumption, ordering solutions, five common pitfalls, and a five-layer eventual consistency architecture.

Distributed SystemsIdempotencyLocal Event Table
0 likes · 12 min read
Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 5, 2026 · Backend Development

MQ Ordered Consumption: Partial Order Patterns, Code Examples & Interview Guide

This article explains how to guarantee message ordering in message queues by comparing RocketMQ, Kafka, and RabbitMQ implementations, detailing partial ordering via business key hashing, providing production-ready code for producers and consumers, and covering business-level safeguards like state machines and idempotency to handle queue rebalancing and head-of-line blocking.

Head-of-line BlockingIdempotencyKafka
0 likes · 25 min read
MQ Ordered Consumption: Partial Order Patterns, Code Examples & Interview Guide
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.

BackendDistributed SystemsMessage Queue
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.

ClusterHigh AvailabilityMessage Queue
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.

BackendMessage QueueRedis
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.

IdempotencyMessage QueueOrdered Messaging
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.

LuaMessage QueueMySQL
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 theoremDistributed SystemsMessage Queue
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.

JavaMessage QueueSpring
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.

Asynchronous ProcessingDecouplingMessage Queue
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.

Message QueueRedisSpring
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 TransactionIdempotencyJava
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.

Distributed SystemsIdempotencyKafka
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 NativeJetStreamMessage Queue
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.

Message QueueRedis optimizationcounter architecture
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.

Asynchronous ProcessingDecouplingKafka
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.

KafkaMessage QueueRabbitMQ
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.

Leaky BucketMessage Queueadaptive throttling
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.

Leaky BucketMessage Queueadaptive throttling
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 HandlingDead Letter QueueIdempotency
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 ProgrammingConcurrencyJava
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.

Distributed SystemsKafkaMessage Queue
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.

Message Queuebacklog preventionbackpressure
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.

Auto ScalingMessage Queuebacklog 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.

FailoverMessage Queueasynchronous 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 SystemsIdempotencyMessage Queue
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 QPSDistributed SystemsMessage Queue
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.

Message QueueRPCbatch processing
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.

Distributed SystemsMessage QueueOptimistic 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.

Dead Letter QueueDelayed Message PluginInterview
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 PatternsJava
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 awarenessDistributed SystemsHigh Availability
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.

Asynchronous ProcessingIdempotencyKafka
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.

Message QueueNginxRedis
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.

Message QueueTwo-Phase Commitdistributed transactions
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 MessagingMessage QueueOutbox Pattern
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.

Message QueueOutbox 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.

KubernetesMessage QueueRedis
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.

Distributed SystemsKafkaMessage Queue
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.

IdempotencyKafkaMessage Queue
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 NativeJavaKafka
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.

Batch ConsumptionKafkaMessage Queue
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.

Message Queuebackpressureconsumer parallelism
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 BreakingKubernetesMessage Queue
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.

JavaMessage QueueOutbox
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.

Distributed SystemsKafkaMessage Queue
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.

DelayQueueMessage QueueRabbitMQ
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.

JavaMessage QueueRabbitMQ
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.

KafkaMessage QueuePulsar
0 likes · 12 min read
Designing a Hundred‑Billion‑Scale Message Queue: A ByteDance Interview Walkthrough