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.
This article walks through the step‑by‑step design of a production‑ready AIOps platform that tackles massive alert storms in a large e‑commerce environment by unifying signal ingestion, deduplication, RBAC, outbox‑driven event publishing, and sub‑second WebSocket push, all backed by Spring Boot 3.x, MySQL, Redis and RocketMQ.
The ACM FSE‑2026 industry paper introduces a replication‑free failover mechanism for cloud‑native stateful services like Apache RocketMQ, using protocol‑level write isolation and multi‑attach storage to achieve second‑level recovery without extra data copies, while maintaining low cost and near‑native throughput.
This white‑paper dissects why a monolithic MySQL‑based order service collapses under peak traffic and presents a layered, asynchronous architecture—using Redis for stock pre‑allocation, RocketMQ for transactional messaging, sharding, idempotency, and comprehensive observability—to reliably handle tens of millions of queries per second.
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.
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.
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.
During a traffic peak the order service saw 30‑second consumer latency and a backlog of over 20 000 messages; by adjusting five RocketMQ consumer parameters—pullBatchSize, consumeThreadMin/Max, adjustThreadPoolNumsThreshold, pullTimeoutMillis, socketTimeoutMillis, and consumeMessageBatchMaxSize—the team reduced end‑to‑end latency to 500 ms, raised TPS to over 2500, and cleared the backlog.
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.
This article introduces a runnable microservices learning project built with three independent Spring Boot applications (gateway, order, stock) and middleware such as Nacos, MySQL, Redis, RocketMQ, and Seata, guiding readers through cloning the repository, starting the environment with Docker Compose, and verifying the end‑to‑end product‑order‑stock flow.
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.
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.
The article analyzes the pitfalls of synchronous calls in a payroll microservice, defines domain events and their naming conventions, compares them with message‑queue messages, and presents two concrete implementations—Spring ApplicationEvent for intra‑process decoupling and RocketMQ with a transactional outbox for cross‑process communication—while also clarifying when event sourcing is appropriate.
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.
The article analyses why sending a message is easy but guaranteeing end‑to‑end consistency across databases, brokers, networks and services is hard, explains the exact problems RocketMQ transactional messages solve, compares them with Outbox and CDC, and provides a complete production‑grade design, implementation, monitoring and tuning guide.
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.
This article walks through setting up the foundational environment for a real‑time data visualization pipeline using RocketMQ, Flink, Elasticsearch and Kibana, covering code configuration, index verification, Kibana dashboard creation, and practical production tips.
This article walks through setting up a real‑time dashboard stack using RocketMQ, Flink, Elasticsearch and Kibana, covering environment preparation, order data simulation, Flink job creation with source, transformation and Elasticsearch upsert sink, and visualisation considerations.
This article analyzes RocketMQ’s storage high‑availability, detailing the CommitLog, ConsumeQueue, flushing and replication mechanisms, comparing traditional master‑slave, DLedger and Controller modes, and provides engineering configurations, code examples, capacity planning, Kubernetes deployment, monitoring and recovery practices for production‑grade fault tolerance.
The article explains why RocketMQ inevitably delivers duplicate messages under at‑least‑once semantics, analyzes root causes in producer, broker and consumer stages, and presents a production‑grade idempotent solution that combines business keys, Redis caching, Redisson locks, a MySQL idempotent table, AOP interception, and comprehensive monitoring to guarantee exactly‑once business outcomes even under high concurrency and Kubernetes graceful shutdown.
The Agentic AICon event gathered over 180 technical professionals to dissect enterprise‑scale agent engineering, presenting the full lifecycle of Agent Infra—including construction, deployment, observability, and intelligent operations—through detailed sessions on HiClaw, AgentRun, AgentLoop, STAROps, and a RocketMQ‑based asynchronous architecture.
The article explains a structured business‑trace logging pattern that records each critical step of a workflow as a node, stores logs in a dedicated MySQL database, aggregates them by a business number, and presents them in a sortable, color‑coded front‑end for both developers and business users.
This tutorial walks through deploying a highly available RocketMQ cluster with Docker Compose, configuring master‑slave brokers, enabling message tracing, integrating Prometheus‑Grafana monitoring, setting up Spring Boot HA properties, applying performance tweaks, validating failover, and troubleshooting common issues.
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.
This article explains why message ordering is critical for order‑state flows, demonstrates how to use RocketMQ's ordered messaging and dead‑letter queue features in a Spring Cloud project, shows the full project structure, provides runnable code, testing steps, performance numbers, and common pitfalls.
This article demonstrates how Spring Cloud Stream provides a unified programming model that decouples business logic from the underlying message broker, allowing a single codebase to work with RocketMQ, Kafka, or RabbitMQ by only changing configuration, and walks through project structure, implementation, conditional routing, MQ switching, testing, and common pitfalls.
This tutorial explains why microservices need a message queue, outlines RocketMQ’s core concepts, shows how to set up RocketMQ with Docker Compose, integrates it into Spring Boot projects with detailed producer and consumer code, provides testing steps, and lists common pitfalls and solutions.
At billion‑level request rates, the traditional cache‑aside pattern fails, so the article proposes a three‑layer architecture—Canal captures MySQL binlog, an MQ (RocketMQ/Kafka) buffers changes, and a coordinated local cache service updates L1 caches with short TTL, achieving high performance and eventual consistency.
The article analyzes a real-world sports‑venue management platform, detailing how multi‑level caching, asynchronous processing with RocketMQ, database sharding, service splitting, and Kubernetes auto‑scaling together reduced average response time from 1200 ms to 150 ms, increased throughput eightfold, and achieved 99.95% availability under tens of thousands of QPS.
This guide walks you through the entire lifecycle of a RocketMQ message, identifies where loss can occur, provides step‑by‑step diagnostics using TrackType and timestamps, and offers concrete configuration, command‑line and recovery strategies for producers, brokers and consumers.
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.
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.
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.
The article explains RocketMQ's ordered messaging model, detailing why disorder occurs during production and consumption, and describing the three-phase mechanism—using MessageQueueSelector, sequential storage, and single‑threaded ordered consumption—to ensure that messages are processed in the exact order they were produced.
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.
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.
This article explains how SpringBoot handles transactional messaging to achieve distributed data consistency, covering the concept of transaction messages, CAP theory, final consistency, and three practical implementations using a local message table, Kafka transactions, and RocketMQ, plus idempotency and compensation strategies.
This article examines why message ordering is critical in distributed systems, explains how partition mechanisms in Kafka, RocketMQ, and RabbitMQ enable ordered consumption, and provides detailed SpringBoot implementations, best‑practice guidelines, partition‑key design principles, concurrency settings, idempotency, and real‑world case studies to ensure reliable sequential processing.
This article explains how to use dead‑letter queues (DLX) to isolate failed messages in distributed SpringBoot applications, compares RabbitMQ and RocketMQ support, and presents a complete compensation framework with design principles, code examples, best‑practice guidelines, and a real‑world case study showing a 96% reduction in dead‑letter traffic.
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.
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.
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.
This article walks through why modern systems need a message broker, presents a four‑layer architectural view, compares Kafka, RabbitMQ and RocketMQ across design, performance, routing and transactional capabilities, and offers concrete scenario recommendations, engineering best‑practices, code samples and monitoring guidelines.
This article explains why traditional distributed transactions fail, then details the core principles, state flow, and practical Java/Spring Boot implementation of an atomic‑level RocketMQ transactional message wrapper, covering schema design, idempotency, high‑concurrency handling, monitoring, and deployment for production‑grade microservices.
This guide walks through setting up a two‑node RocketMQ cluster with dual master‑slave asynchronous replication, covering host role assignment, configuration file edits, binary deployment, memory tuning, and the exact commands to start NameServers, master brokers, and slave brokers.
This article analyzes the bottlenecks of real‑time AI voice agents in high‑concurrency scenarios and presents a cloud‑native messaging architecture built on Alibaba Cloud RocketMQ LiteTopic that ensures session stickiness, low latency, automatic channel management, and observable operations for scalable, reliable voice interactions.
AgentScope Java, released by Alibaba's Tongyi Lab, tackles the integration, security, and operational challenges of deploying AI agents in Spring Cloud‑based enterprise systems by introducing a production‑grade ReAct paradigm, real‑time interruption, sandboxing, A2A communication via RocketMQ, and visual debugging tools, all demonstrated with concrete code examples and a detailed feature comparison.
The article analyses why message queues are not a cure‑all, using real e‑commerce and finance incidents to dissect the three core benefits—decoupling, asynchronous processing, and peak‑shaving—while exposing production challenges such as loss, duplication, ordering, dead‑letter handling, and end‑to‑end consistency, and offering concrete Java code, benchmark tables and a practical MQ selection guide.
Facing explosive growth, the game‑service platform 悠悠有品 rebuilt its architecture on Alibaba Cloud, using RocketMQ for core transaction messaging and Kafka for data synchronization, achieving elastic scaling, high availability, cost reduction, and reliable high‑concurrency processing across its trading and analytics pipelines.
This article explains why traditional message‑queue throttling fails in AI inference workloads, introduces Apache RocketMQ 5.x LiteTopic’s lightweight topic model, and details its four core features—physical isolation, elastic scaling, precise flow control, and consumption suspension—that together provide millisecond‑level real‑time throttling and minute‑level busy‑idle scheduling for personalized traffic management.
This article introduces AgentScope Java 1.0, an enterprise‑grade AI agent framework for Java that solves stack fragmentation, security, operations, and multi‑agent collaboration challenges by adopting the ReAct paradigm, offering real‑time interruption, sandbox isolation, RocketMQ‑based A2A communication, visual debugging, and deep Spring Cloud integration.
This article explains the unique challenges of using message queues for AI inference workloads, why traditional throttling methods fall short, and how Apache RocketMQ 5.x's LiteTopic introduces lightweight topics, fine‑grained flow control, physical isolation, and consumption suspension to achieve millisecond‑level real‑time throttling and minute‑level busy‑idle scheduling.
AgentScope Java 1.0, open‑sourced by Alibaba, provides a production‑ready AI agent framework built for Java ecosystems, addressing stack fragmentation, security, operations, and multi‑agent collaboration through ReAct reasoning, real‑time interruption, sandboxing, RocketMQ‑based A2A communication, and visual debugging, with detailed integration guides and comparison to LangChain4j and Spring AI.
The article details how the "Qinbao" parenting app, serving over ten million daily active users and massive photo/video uploads, tackled high‑concurrency writes, instant cross‑device notifications, and distributed transaction consistency by migrating to Alibaba Cloud RocketMQ 5.x Serverless, achieving millisecond latency, elastic scaling, and near‑perfect reliability.
The article outlines the motivation, phased planning, architecture, task breakdown, implementation, and testing of a compact reminder platform built with Java 17/SpringBoot 3, Vue 3, Uniapp, MyBatisPlus, Redis, and RocketMQ, detailing each functional module and UI screen.
This article explains the interview focus points for RocketMQ ordered messages, details the partition‑ordered model and its two‑step guarantee mechanism, provides in‑depth analysis of producer and consumer processes, includes full Java code examples, and outlines best practices, pitfalls, and common misconceptions.
This article breaks down the interview focus points, core answer, deep analysis, code examples, and common pitfalls for ensuring RocketMQ messages never get lost, covering producer, broker, and consumer configurations, trade‑offs, and practical troubleshooting steps.
This article breaks down the interview focus points, core solution framework, underlying RocketMQ mechanisms, step‑by‑step remediation actions, common pitfalls, and a concluding strategy for handling message backlog through emergency scaling, consumer optimization, degradation, dead‑letter handling, and proactive capacity planning.
This article explains how RocketMQ’s consumer model is fundamentally pull‑based with a long‑polling optimization that provides a push‑like experience, covering interview focus points, detailed mechanism, code examples, best practices, and common misconceptions.
This article examines the common data‑consistency challenges when writing to both a database and a Redis cache, evaluates four write‑order strategies, and presents the most reliable approach—writing to the database first then deleting the cache—along with retry mechanisms using scheduled jobs, message queues, and binlog listeners.
This tutorial walks through configuring Canal in cluster mode, enabling MySQL binlog, creating an Elasticsearch index, setting up RocketMQ topics, adjusting Canal properties and instance files, launching services, and implementing a consumer to reliably synchronize MySQL changes into Elasticsearch.
This article compares the storage models, data organization, indexing, read/write processes, and performance trade‑offs of three major message queues—Kafka, RocketMQ, and JMQ—providing detailed technical insights for architects and engineers making storage‑related design decisions.
This article dissects a common interview question about Kafka's higher throughput versus RocketMQ's richer features, explains the underlying design philosophies, storage models, I/O paths, scaling limits, real‑world use cases such as transaction, delayed and ordered messages, and provides concrete optimization steps and code samples to help engineers make an informed messaging platform choice.
This article explains RocketMQ's transactional message mechanism, detailing its three‑phase workflow, half‑message handling, transaction checks, key implementation tips, and production‑grade best practices for achieving reliable eventual consistency in distributed systems.
This guide explains why modern distributed enterprises need a reliable, high‑throughput messaging system, outlines core concepts, design principles, technology selection, architecture components, best‑practice implementation steps, and provides concrete Kafka producer and consumer code examples.
This comprehensive guide explores RocketMQ’s four‑component architecture, storage formats, routing mechanisms, write‑and‑read workflows, high‑availability designs, performance optimizations, and a side‑by‑side comparison with Kafka, providing practical insights for building robust distributed messaging systems.
This guide explains why delayed messages are essential for distributed system stability, compares RabbitMQ's TTL+DLX and delayed‑message plugin, details RocketMQ's precise timing and delay‑level features, and offers custom Redis and time‑wheel solutions with practical Java code examples and deployment tips.
RocketMQ ensures durable, consistent, and highly available message storage through fixed‑length append‑only files, efficient index rebuilding, checkpoint tracking, and configurable master‑slave replication, offering both synchronous and asynchronous HA modes, detailed recovery steps, performance trade‑offs, and practical operational guidelines for robust fault tolerance.
To reliably handle RocketMQ's at-least-once delivery semantics, this guide explains why duplicate consumption is inevitable, outlines three defensive layers—Redis‑based idempotency, database unique constraints, and state‑machine checks—provides production‑grade Java code, and details ACK/retry strategies and monitoring practices for robust systems.
This guide explains the two main steps for expanding a RocketMQ cluster—scaling brokers and scaling name servers—detailing when to add resources, configuration changes, and command examples for a smooth horizontal expansion.
This article dissects the interview question “Should thread pools be shared or exclusive?” by exposing common pitfalls, presenting a systematic analysis of isolation versus reuse, and illustrating best‑practice designs with concrete RocketMQ examples, code snippets, and decision‑making guidelines.
An in‑depth guide to Apache RocketMQ 4.x producer SDK covers essential and optional configurations, internal startup and sending workflows, transaction and ordered messaging, failure handling, performance tuning, monitoring, and practical code examples to help you build a reliable, high‑throughput messaging system.
The article explains how RocketMQ 5.x’s storage‑compute decoupling and POP consumption model require a new gRPC client, and how Tencent Cloud’s virtual‑queue solution provides full compatibility for legacy Remoting SDKs by abstracting queues and transparently converting consumption modes, eliminating client‑side rebalance and preserving order guarantees.
This article explains the communication challenges of modern multi‑agent AI applications and demonstrates how RocketMQ for AI’s event‑driven, asynchronous messaging architecture can improve scalability, reliability, and cost efficiency through a step‑by‑step weather‑and‑travel planning example.
This article provides an in‑depth, multi‑dimensional comparison of Apache Kafka, RabbitMQ, and Apache RocketMQ—covering design philosophy, performance, reliability, features, ecosystem, operations, and typical scenarios—to help you choose the right message middleware for your architecture.
This article explains how to use RocketMQ's transactional messages and an atomic‑level wrapper to achieve sub‑second final consistency for million‑scale transaction systems, detailing the two‑phase commit workflow, annotation‑driven implementation, performance optimizations, failure handling, monitoring, and suitable use cases.
This guide walks you through the complete Docker‑based deployment of RocketMQ 5.x, explaining the new Proxy‑centric architecture, showing Docker Compose and manual run methods, providing full configuration files, startup commands, verification steps, production‑grade optimizations, monitoring setup, and troubleshooting tips.
This article explains how a large e‑commerce platform implements a high‑performance, asynchronous Excel export mechanism using annotation‑driven declarative programming, AOP interception, Quartz scheduling, RocketMQ messaging, and OSS storage to handle massive data sets without blocking user requests.
This article provides a comprehensive overview of RocketMQ, covering its core components (Producer, Broker, Consumer, NameServer), detailed architecture diagrams, step‑by‑step message production and consumption processes, and typical scenarios such as asynchronous decoupling, traffic shaping, transactional messaging, and event‑driven logging.
This comprehensive guide explains the core components, exchange types, TTL, confirm mechanisms, consumer ACK/NACK, dead‑letter queues, and high‑availability features of RabbitMQ, RocketMQ, and Kafka, while also covering load balancing, ordering, transaction handling, and best practices for reliable message delivery.
This article presents a detailed design for a high‑concurrency (10‑100k QPS) distributed transaction solution that integrates RocketMQ transactional messages, an eBay‑style local message table, and XXL‑Job reconciliation to achieve eventual consistency while handling failures, retries, and data‑explosion challenges.
This article details PalmPay's rapid growth in Africa, the technical challenges it faced with transaction consistency, high‑throughput messaging, and resource elasticity, and how adopting Alibaba Cloud RocketMQ—both standard and Serverless versions—provided a robust, scalable, and cost‑effective cloud‑native solution.
Learn how to design a robust, high‑performance seckill architecture that can endure millions of concurrent requests by breaking down business flow, defining precise technical metrics, and implementing a four‑layer system—access, traffic‑shaping, business logic, and data—using CDN, APISIX, Redis, RocketMQ, and MySQL with detailed code examples.
Alibaba Cloud unveiled a fully open‑source AI middleware suite—including AgentScope‑Java, AI‑MQ (RocketMQ), Higress gateway, Nacos registration/configuration, and AI observability—to enable enterprise‑grade, multi‑Agent AI applications, addressing integration, scalability, and reliability challenges highlighted by recent Gartner forecasts.
Learn a step‑by‑step solution to deploy a production‑grade RocketMQ cluster on Kubernetes, covering architecture design with StatefulSets, Helm chart or native YAML configurations, persistent storage, external access, monitoring, security hardening, and one‑click installation commands.
This guide walks you through designing, preparing the environment, installing, configuring, and validating a production‑grade RocketMQ cluster with multiple masters and slaves, including optional web console setup, one‑click deployment scripts, performance tuning, security hardening, and monitoring recommendations.
This article walks through seven essential RocketMQ concepts—including message ordering, delayed delivery, accumulation handling, transactional guarantees, retry mechanisms, storage strategies, and filtering—providing code examples, configuration tips, and visual diagrams to help developers build robust distributed messaging systems.
This article explores ten practical use‑cases for message queues—covering system decoupling, asynchronous processing, traffic shaping, data synchronization, log collection, broadcast updates, ordered and delayed messages, retry mechanisms, and transactional messaging—illustrated with Java code examples and architectural diagrams.
This article explores the sequential consumption mechanisms of RocketMQ and its derivative DDMQ, detailing the underlying source‑code implementation, differences in producer ordering, broker handling, consumer locking, and how DDMQ simplifies ordering with a single‑node proxy, complete with code examples and diagrams.
This article explains why message queues can accumulate millions of messages, analyzes root causes such as over‑fast producers and slow consumers, and presents five practical solutions—including consumer code optimization, queue‑strategy tweaks, producer rate limiting, dead‑letter handling, and automated monitoring—to dramatically reduce backlog without costly hardware scaling.
RocketMQ tackles the high‑performance, high‑reliability challenges of distributed messaging by combining sequential disk writes, memory caching, and multi‑level indexing, detailing its storage logic, core structures, zero‑copy techniques, replication modes, static topic scaling, and practical tuning guidelines for optimal throughput.
This article deeply explores the sequential consumption mechanisms of RocketMQ and its derivative DDMQ, comparing their source‑code implementations, detailing producer ordering, broker locking, consumer locking, and the architectural differences that allow DDMQ to achieve ordered processing with only proxy‑side locks.
This article deeply explores the ordered consumption mechanisms of RocketMQ and its derivative DDMQ, explaining the implementation differences, source‑code details of sequential sending, broker locking, client‑side processing, and compares the two systems' approaches to guarantee message order.
This article provides a comprehensive overview of RocketMQ's architecture, detailing its core components, network protocols, storage mechanisms, producer‑consumer workflow, and transactional messaging, while highlighting differences between Remoting and gRPC and explaining key design choices for high performance and reliability.
At 2 AM an alert triggered when a RocketMQ queue surged from 500 K to 10 M messages, causing severe latency; the article walks through root‑cause analysis, a five‑step emergency fix, long‑term architectural upgrades, monitoring, and scripts to reliably eliminate such MQ backlogs.
This article provides a comprehensive technical overview of RocketMQ 4.x, covering its core roles, publish‑subscribe model, communication protocol, reactor thread model, storage files, high‑performance read/write techniques, consumption flow, deployment patterns, DLedger Raft integration, transaction and broadcast messaging, ordered message handling, architectural drawbacks, and the new stateless proxy architecture introduced in RocketMQ 5.0.
During massive daily imports of up to one million reconciliation records, MySQL deadlocks can cripple performance; this article dissects the four classic deadlock conditions, then presents a systematic “One‑Order Four‑Split” strategy—ordered writes, transaction splitting, index management, partitioning, and gap‑lock removal—backed by benchmarks, code samples, and configuration tweaks that cut lock rates by up to 90% and reduce batch times to under ten minutes.
This article provides a comprehensive overview of RocketMQ 4.x, detailing its core architecture—including NameServer, Broker, Producer, and Consumer roles—its publish‑subscribe model, its communication protocols, reactor threading, storage mechanisms, high‑performance read/write strategies, deployment options, transaction handling, broadcast and ordered messaging, and the strengths and limitations of its master‑slave and DLedger designs.
This article explains how TDMQ RocketMQ's transactional messaging works, covering the underlying concepts, three‑phase processing flow, key terminology, source‑code details, practical Java examples, and important considerations for building reliable distributed transactions.
This article deeply explores Apache RocketMQ's retry mechanisms, detailing producer and consumer retry strategies, flow control handling, dead‑letter queue management, advanced configurations, best practices, and comparisons with Kafka and RabbitMQ, providing practical code examples and monitoring recommendations for building highly reliable distributed systems.
