BestHub
Sign in
Tagged articles
972 articles
Page 10 of 10
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 20, 2017 · Backend Development

Synchronous vs Asynchronous Messaging: When to Use Queues and How They Impact Performance

This article explains the fundamental differences between synchronous and asynchronous communication, explores how message queues decouple producers and consumers, and discusses key considerations such as persistence, performance, reliability, and language support for building robust backend systems.

Message QueueReliabilitySynchronous
0 likes · 9 min read
Synchronous vs Asynchronous Messaging: When to Use Queues and How They Impact Performance
Architecture Digest
Architecture Digest
Sep 10, 2017 · Backend Development

Understanding Distributed Transaction Patterns: TCC, Asynchronous Assurance, and Maximum Effort Notification

The article explains common interview questions on distributed systems and compares transaction coordination methods, detailing the two‑phase commit drawbacks and introducing three patterns—TCC, asynchronous assurance, and maximum‑effort notification—along with their advantages, usage scenarios, and practical considerations.

Backend DevelopmentMessage Queueasynchronous assurance
0 likes · 4 min read
Understanding Distributed Transaction Patterns: TCC, Asynchronous Assurance, and Maximum Effort Notification
Architecture Digest
Architecture Digest
Aug 30, 2017 · Backend Development

Evolution of System Architecture and Key Distributed Service Technologies

This article outlines the progressive stages of system architecture—from a single‑server LAMP setup through application‑data separation, caching, clustering, read/write splitting, CDN, distributed storage, NoSQL, business decomposition, and finally distributed services—while detailing essential technologies such as message queues, service frameworks, service buses, communication patterns, and governance mechanisms like Dubbo and OSB.

Backend DevelopmentDistributed SystemsMessage Queue
0 likes · 14 min read
Evolution of System Architecture and Key Distributed Service Technologies
21CTO
21CTO
Jul 23, 2017 · Backend Development

Comparing Kafka and RocketMQ: Architecture, Availability, and Reliability Insights

This article examines the architectures of Kafka and RocketMQ, analyzes their availability and reliability mechanisms, evaluates their strengths and weaknesses, and proposes a hybrid MQ design that combines the benefits of both systems while simplifying dependencies and improving fault tolerance.

AvailabilityKafkaMessage Queue
0 likes · 13 min read
Comparing Kafka and RocketMQ: Architecture, Availability, and Reliability Insights
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 24, 2017 · Backend Development

Master RocketMQ on CentOS: Deployment, Client Code, and Best Practices

This guide walks through installing RocketMQ on a CentOS 6.5 VM, launching NameServer and Broker, provides sample Java consumer and producer code, and outlines best‑practice tips for idempotent consumption, batch processing, message filtering, performance tuning, and reliable message delivery.

Best PracticesDeploymentMessage Queue
0 likes · 13 min read
Master RocketMQ on CentOS: Deployment, Client Code, and Best Practices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 23, 2017 · Backend Development

Unlocking RocketMQ: Core Features, Architecture, and Performance Secrets

RocketMQ is a distributed queue-based middleware offering strict message ordering, diverse pull modes, scalable subscribers, real-time subscription, and massive message accumulation, with detailed network deployment, storage mechanisms, key features, flushing strategies, query methods, server-side filtering, JVM memory utilization, and solutions for message backlog.

Backend DevelopmentMessage QueueRocketMQ
0 likes · 14 min read
Unlocking RocketMQ: Core Features, Architecture, and Performance Secrets
ITPUB
ITPUB
May 19, 2017 · Backend Development

How Message Queues Turn Slow Email Sends into Fast, Reliable Services

This article tells the story of a developer who first used a blocking email call, then switched to multithreading, and finally adopted a message queue to achieve asynchronous processing, decoupling, scalability, and reliability for user registration emails.

Backend ArchitectureDistributed SystemsJava Multithreading
0 likes · 6 min read
How Message Queues Turn Slow Email Sends into Fast, Reliable Services
WeChat Backend Team
WeChat Backend Team
May 7, 2017 · Backend Development

How WeChat’s MQ 2.0 Redefined Asynchronous Queues for Massive Scale

This article explains the design and improvements of WeChat's MQ 2.0 asynchronous queue, covering its cross‑machine consumption model, enhanced task scheduling, MapReduce‑style processing, stream tasks, and robust overload protection that together enable high‑performance, resilient backend services.

Backend ArchitectureMessage QueueTask Scheduling
0 likes · 13 min read
How WeChat’s MQ 2.0 Redefined Asynchronous Queues for Massive Scale
Qunar Tech Salon
Qunar Tech Salon
May 5, 2017 · Backend Development

WeChat MQ 2.0: Enhanced Asynchronous Queue Design and Optimizations

The article introduces WeChat's self‑developed MQ 2.0 asynchronous queue, detailing its architecture, cross‑machine consumption model, improved task scheduling, efficient processing frameworks—including a MapReduce‑style engine and streaming tasks—and robust overload protection mechanisms that together boost reliability and performance for large‑scale backend services.

Distributed SystemsMapReduceMessage Queue
0 likes · 12 min read
WeChat MQ 2.0: Enhanced Asynchronous Queue Design and Optimizations
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 21, 2017 · Backend Development

Mastering Producer‑Consumer and Pub/Sub with RabbitMQ: Real‑World Patterns Explained

This article explains the producer‑consumer and publish‑subscribe messaging patterns, introduces RabbitMQ’s core concepts such as exchanges, queues, routing keys, and reliability mechanisms, and demonstrates how to apply these patterns to data ingestion and event distribution scenarios with practical diagrams.

Backend ArchitectureMessage QueueMessaging Patterns
0 likes · 9 min read
Mastering Producer‑Consumer and Pub/Sub with RabbitMQ: Real‑World Patterns Explained
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 21, 2017 · Backend Development

Mastering Kafka: Producer‑Consumer vs Pub/Sub Patterns for Scalable Backend Design

This article explains Kafka's core concepts and compares producer‑consumer and publish‑subscribe models, illustrating how to apply each pattern for data ingestion and event distribution in distributed backend systems, and offers practical design alternatives when Kafka’s native capabilities fall short.

Backend ArchitectureKafkaMessage Queue
0 likes · 10 min read
Mastering Kafka: Producer‑Consumer vs Pub/Sub Patterns for Scalable Backend Design
Architecture Digest
Architecture Digest
Mar 3, 2017 · Operations

High-Concurrency Architecture: Strategies, Testing, and Practical Solutions

This article outlines the design and implementation of high‑concurrency systems, covering server architecture, load balancing, database clustering, caching strategies, message‑queue based asynchronous processing, static data handling, and operational best practices such as monitoring, redundancy, and automation.

CachingMessage QueueOperations
0 likes · 18 min read
High-Concurrency Architecture: Strategies, Testing, and Practical Solutions
dbaplus Community
dbaplus Community
Feb 13, 2017 · Backend Development

Why Message Queues Are Essential for Scalable Distributed Systems

Message queues act as a crucial middleware component in distributed systems, addressing coupling, asynchronous processing, traffic shaping, and high availability, with real-world scenarios such as asynchronous handling, decoupling, traffic throttling, logging, and communication, while reviewing popular solutions like ActiveMQ, RabbitMQ, ZeroMQ, Kafka, and JMS.

Backend ArchitectureJMSKafka
0 likes · 20 min read
Why Message Queues Are Essential for Scalable Distributed Systems
Ctrip Technology
Ctrip Technology
Jan 25, 2017 · Backend Development

Handling Duplicate Messages, Ordering, Concurrency, and Batch Processing in Message‑Driven Systems

This article shares practical patterns and built‑in mechanisms for dealing with duplicate messages, message ordering, concurrent updates, asynchronous acknowledgments, and batch processing in a large‑scale, message‑driven architecture, illustrated with QMQ examples from Qunar's platform.

Backend DevelopmentBatch ProcessingConcurrency Control
0 likes · 16 min read
Handling Duplicate Messages, Ordering, Concurrency, and Batch Processing in Message‑Driven Systems
dbaplus Community
dbaplus Community
Dec 14, 2016 · Backend Development

Master Memcached, Redis, and RabbitMQ: Install, Configure, and Use with Python

This guide walks through the fundamentals, installation steps, configuration details, and Python integration for three essential backend services—Memcached for high‑performance caching, Redis for persistent key‑value storage, and RabbitMQ for reliable messaging—complete with command‑line examples, code snippets, and best‑practice tips.

Backend DevelopmentCachingMemcached
0 likes · 19 min read
Master Memcached, Redis, and RabbitMQ: Install, Configure, and Use with Python
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Dec 2, 2016 · Backend Development

Mastering Distributed Transaction Consistency: From CAP to Message‑Based Compensation

This article examines the fundamental challenges of achieving consistency in distributed systems, explains the CAP theorem, compares two‑phase and three‑phase commit protocols, explores XA transactions, and presents practical compensation patterns such as local message tables, non‑transactional and transactional MQ designs, highlighting their trade‑offs and applicability.

CAP theoremDistributed SystemsMessage Queue
0 likes · 15 min read
Mastering Distributed Transaction Consistency: From CAP to Message‑Based Compensation
High Availability Architecture
High Availability Architecture
Nov 25, 2016 · Backend Development

Disque: An Experimental Distributed In‑Memory Message Queue – Design and Usage Overview

Disque is an experimental, distributed, fault‑tolerant in‑memory message queue built in C that extends Redis concepts with synchronous replication, configurable delivery semantics, explicit acknowledgments, fast‑ack support, dead‑letter handling, and optional disk persistence for robust backend messaging workloads.

DisqueIn-MemoryMessage Queue
0 likes · 17 min read
Disque: An Experimental Distributed In‑Memory Message Queue – Design and Usage Overview
Architecture Digest
Architecture Digest
Nov 24, 2016 · Backend Development

High Concurrency Architecture and Practical Solutions for E‑commerce Applications

This article outlines the challenges of high‑traffic scenarios such as flash sales and timed red‑packet distribution, and presents a comprehensive backend architecture—including load balancing, database clustering, NoSQL caching, CDN, concurrency testing, message queues, first‑level caching, and static data strategies—to ensure smooth operation and optimal user experience.

Backend ArchitectureCachingMessage Queue
0 likes · 11 min read
High Concurrency Architecture and Practical Solutions for E‑commerce Applications
Architecture Digest
Architecture Digest
Nov 19, 2016 · Backend Development

Why Distributed Systems Are Essential for Scaling Internet Services and How to Build Them

The article explains that massive user traffic forces servers to adopt distributed systems to achieve high throughput, concurrency, low latency, and load balancing, and it details architectural patterns, concurrency models, caching, storage, coordination, messaging, transaction, deployment, and monitoring techniques for building and managing such systems.

CachingDistributed SystemsMessage Queue
0 likes · 39 min read
Why Distributed Systems Are Essential for Scaling Internet Services and How to Build Them
Architecture Digest
Architecture Digest
Nov 8, 2016 · Backend Development

Why Replace Distributed Transactions? A Message Queue and State‑Table Solution

The article explains the drawbacks of traditional two‑phase commit distributed transactions—reduced availability, performance, and scalability—and proposes a message‑queue‑plus‑state‑table pattern with idempotent processing to achieve eventual consistency while improving system throughput.

Backend ArchitectureMessage QueueScalability
0 likes · 7 min read
Why Replace Distributed Transactions? A Message Queue and State‑Table Solution
dbaplus Community
dbaplus Community
Nov 1, 2016 · Information Security

Exploiting Message Queue Injection to Hijack Distributed Nodes with Celery

The article explains how insecure serialization in message‑queue middleware, especially Python's pickle used by Celery, can be abused to inject malicious payloads that trigger remote code execution on distributed workers, and it demonstrates detection and exploitation techniques against vulnerable Redis and MongoDB brokers.

Message QueuePythonRedis
0 likes · 17 min read
Exploiting Message Queue Injection to Hijack Distributed Nodes with Celery
ITPUB
ITPUB
Oct 22, 2016 · Backend Development

Designing Scalable High‑Concurrency Architecture: Practical Strategies and Patterns

This guide explains how to design and test high‑concurrency systems by choosing appropriate server architectures, load‑balancing, database clustering, caching layers, message queues, first‑level caches, and static data strategies to ensure smooth operation under heavy user traffic.

Backend ArchitectureCachingDistributed Systems
0 likes · 12 min read
Designing Scalable High‑Concurrency Architecture: Practical Strategies and Patterns
dbaplus Community
dbaplus Community
Oct 19, 2016 · Backend Development

When to Use Kafka, RabbitMQ, or ZeroMQ: A Practical MQ Guide

This article explains the true purpose of message queues, classifies them into broker‑based and broker‑less families, compares Kafka, RabbitMQ, and ZeroMQ in terms of performance, flexibility, and lightweight distribution, and clarifies that MQs can support both asynchronous and synchronous communication.

KafkaMessage QueueRabbitMQ
0 likes · 8 min read
When to Use Kafka, RabbitMQ, or ZeroMQ: A Practical MQ Guide
Architecture Digest
Architecture Digest
Aug 9, 2016 · Backend Development

Design and Evolution of Xiaomi's Notify Asynchronous Message System

This article details the three-stage evolution of Xiaomi's e‑commerce architecture, introduces the design of the Notify asynchronous message system built on Redis and MySQL, and explains the subsequent upgrades—including agent proxy, Go‑based modules, and MyCAT integration—to improve scalability, reliability, and performance.

GoMessage QueueSystem Architecture
0 likes · 13 min read
Design and Evolution of Xiaomi's Notify Asynchronous Message System
Architecture Digest
Architecture Digest
Jul 31, 2016 · Game Development

Designing Scalable Game Server Architecture: Pipelines, Gate, MQ, and Service‑Oriented Patterns

The article examines common misconceptions about game server performance, outlines essential message pipelines, introduces Gate as a reverse‑proxy for low‑latency scene synchronization, discusses integrating a message‑queue (MQ) for decoupled services, and presents a service‑oriented RPC framework with patterns to build maintainable, scalable multiplayer back‑ends.

GateMessage QueueRPC
0 likes · 34 min read
Designing Scalable Game Server Architecture: Pipelines, Gate, MQ, and Service‑Oriented Patterns
Architecture Digest
Architecture Digest
Jul 14, 2016 · Backend Development

Design and Implementation of a Message/Notification System

This article outlines the concepts, classifications, and detailed backend design of a message/notification system, including architecture, database schemas, subscription mechanisms, push/pull strategies, and service-layer APIs for creating, pulling, and managing announcements, reminders, and messages.

Message QueueNotificationSystem Design
0 likes · 13 min read
Design and Implementation of a Message/Notification System
Architecture Digest
Architecture Digest
Jul 6, 2016 · Backend Development

Designing a Message Queue: Key Considerations and Architecture

The article explains why and when to use message queues, then walks through designing one from scratch, covering decoupling, eventual consistency, broadcast, flow control, RPC protocols, high availability, storage choices, consumer relationships, reliable delivery, transactions, performance optimizations, and push versus pull models.

AsynchronousBackend ArchitectureDistributed Systems
0 likes · 35 min read
Designing a Message Queue: Key Considerations and Architecture
Meituan Technology Team
Meituan Technology Team
Jul 1, 2016 · Backend Development

Designing a Custom Message Queue: Principles and Practices

The article outlines how to design a custom message queue by first identifying appropriate use‑cases such as decoupling, eventual consistency, broadcasting and peak‑shaving, then examining push versus pull models, high‑availability, ordering, duplicate handling, storage choices, batch processing, flow‑control and performance optimizations, with advanced topics reserved for a follow‑up.

Message QueuePerformanceReliability
0 likes · 34 min read
Designing a Custom Message Queue: Principles and Practices
dbaplus Community
dbaplus Community
Jun 1, 2016 · Backend Development

Mastering RabbitMQ: Architecture, Optimization, and Real-World Cases in Microservices

This article explores microservice architecture fundamentals, compares synchronous and asynchronous communication, details RabbitMQ’s AMQP model, optimization techniques, high‑availability configurations, flow‑control mechanisms, and shares practical case studies from NetEase’s Hive platform, offering actionable insights for reliable, scalable message‑queue deployments.

Message QueueMicroservicesPerformance Optimization
0 likes · 18 min read
Mastering RabbitMQ: Architecture, Optimization, and Real-World Cases in Microservices
Big Data and Microservices
Big Data and Microservices
May 12, 2016 · Industry Insights

How 58 Daojia Built a Scalable Real‑Time Messaging Platform: Architecture Deep Dive

This article dissects the design of 58 Daojia’s universal real‑time messaging platform, detailing the challenges of end‑to‑cloud, cloud‑to‑end, and end‑to‑end communication, the shortcomings of traditional HTTP and push solutions, and the optimized TCP, message‑bus, RPC, and protocol extensions that achieve scalability, reliability, and cross‑account chat.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 12 min read
How 58 Daojia Built a Scalable Real‑Time Messaging Platform: Architecture Deep Dive
Architecture Digest
Architecture Digest
May 3, 2016 · Backend Development

Message Patterns and Their Application in Distributed Enterprise Systems

The article examines various messaging patterns—Message Channel, Publisher‑Subscriber, Message Router, and others—explaining their principles, advantages, and implementation details, and illustrates their use in enterprise distributed architectures through concrete code examples and case studies such as CIMS and a medical system.

Distributed SystemsEnterprise ArchitectureIntegration Patterns
0 likes · 31 min read
Message Patterns and Their Application in Distributed Enterprise Systems
21CTO
21CTO
Apr 25, 2016 · Backend Development

Scalable Backend Architecture: Load Balancing, Caching, and Platform Layers

Will Larson’s insights on building scalable systems are distilled here, covering horizontal scalability, redundancy, load balancing strategies, various caching techniques, CDN usage, offline processing with message queues, Map‑Reduce for big data, and the benefits of introducing a dedicated platform layer for robust backend architecture.

Backend ArchitectureCachingMessage Queue
0 likes · 11 min read
Scalable Backend Architecture: Load Balancing, Caching, and Platform Layers
21CTO
21CTO
Apr 19, 2016 · Backend Development

How Alibaba’s Notify and MetaQ Power Massive E‑Commerce Messaging

This article explains the design principles, architecture, and performance optimizations of Alibaba's Notify and MetaQ message middleware, illustrating how they achieve reliable asynchronous communication, high scalability, and low latency for billions of messages during peak e‑commerce events like Double 11.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 14 min read
How Alibaba’s Notify and MetaQ Power Massive E‑Commerce Messaging
Big Data and Microservices
Big Data and Microservices
Apr 14, 2016 · Industry Insights

Inside Twitter’s Scalable Architecture: Following, Caching, and Queues Explained

The article breaks down Twitter’s core business of following and being followed, explains its three‑tier presentation‑logic‑data architecture, details cache strategies, message‑queue isolation, and the push‑pull trade‑offs, illustrating how these components work together to achieve high‑performance, fault‑tolerant service at massive scale.

CachingMessage QueueScalability
0 likes · 11 min read
Inside Twitter’s Scalable Architecture: Following, Caching, and Queues Explained
MaGe Linux Operations
MaGe Linux Operations
Mar 28, 2016 · Backend Development

Understanding JMS: Message Models, Consumption, and Popular Middleware

This article explains the JMS standard, its two messaging models (Point‑to‑Point and Publish/Subscribe), how messages are consumed synchronously or asynchronously, the core JMS programming objects, and provides an overview of common middleware such as ActiveMQ, RabbitMQ, ZeroMQ, and Kafka.

ActiveMQJMSKafka
0 likes · 17 min read
Understanding JMS: Message Models, Consumption, and Popular Middleware
21CTO
21CTO
Mar 24, 2016 · Backend Development

How to Build a Reliable Java Delayed Queue for Scalable Backend Systems

This article explains the design, architecture, and implementation details of a Java-based delayed queue, covering use cases, core components, message lifecycle, protocol, current topology, shortcomings, and future improvements for reliable backend processing.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 10 min read
How to Build a Reliable Java Delayed Queue for Scalable Backend Systems
21CTO
21CTO
Mar 12, 2016 · Backend Development

Designing Scalable Asynchronous Message Queues: Ctrip’s Hermes Architecture Deep Dive

This article examines Ctrip's Hermes asynchronous messaging system, detailing its evolution from a simple Mongo‑backed queue to a broker‑centric, partitioned architecture with lease‑based cluster management, and shares practical techniques for building high‑performance, low‑latency message queues in large‑scale distributed environments.

Backend ArchitectureDistributed SystemsHermes
0 likes · 21 min read
Designing Scalable Asynchronous Message Queues: Ctrip’s Hermes Architecture Deep Dive
Architect
Architect
Mar 12, 2016 · Backend Development

Design and Evolution of Ctrip's Hermes Message Queue System

This article presents a detailed overview of Ctrip's Hermes message queue system, covering its architectural evolution from a simple Mongo‑based design to a broker‑centric, multi‑storage solution with meta‑server coordination, and discusses practical techniques for building high‑performance, scalable messaging infrastructure.

Cluster ManagementCtripDistributed Systems
0 likes · 21 min read
Design and Evolution of Ctrip's Hermes Message Queue System
Architecture Digest
Architecture Digest
Mar 6, 2016 · Backend Development

Message Queue Overview, Application Scenarios, and Middleware Examples

This article introduces the fundamentals of message queues, explains common use cases such as asynchronous processing, system decoupling, traffic shaping, and log handling, and reviews popular middleware implementations including JMS, ActiveMQ, RabbitMQ, ZeroMQ, and Kafka.

Distributed SystemsJMSKafka
0 likes · 18 min read
Message Queue Overview, Application Scenarios, and Middleware Examples
Java High-Performance Architecture
Java High-Performance Architecture
Feb 29, 2016 · Backend Development

How Kafka Stores and Retrieves Messages: Inside Partitions, Segments, and Index Files

Kafka persists messages on disk by organizing each topic into multiple partitions, which are further divided into segment files containing paired .index and .log files; this structure enables efficient storage, offset-based lookup, and fast retrieval of specific messages through binary search across segment indexes.

KafkaMessage QueueStorage Architecture
0 likes · 5 min read
How Kafka Stores and Retrieves Messages: Inside Partitions, Segments, and Index Files
21CTO
21CTO
Feb 14, 2016 · Backend Development

Unlocking High‑Performance Systems: How Message Queues Transform Backend Architecture

This article provides a comprehensive overview of message queues, covering their core concepts, key application scenarios such as asynchronous processing, system decoupling, traffic shaping, log handling, and communication, and examines popular middleware like ActiveMQ, RabbitMQ, ZeroMQ, and Kafka, along with JMS models and programming details.

JMSKafkaMessage Queue
0 likes · 22 min read
Unlocking High‑Performance Systems: How Message Queues Transform Backend Architecture
21CTO
21CTO
Jan 9, 2016 · Backend Development

How Distributed Transactions Keep Money Transfers Consistent Without Locks

This article explains the challenges of ensuring data consistency across multiple databases during operations like Alipay transfers, introduces local and distributed transactions, details the two‑phase commit protocol, and shows how reliable messaging can replace heavyweight distributed transactions for high‑concurrency systems.

Backend DevelopmentData ConsistencyMessage Queue
0 likes · 10 min read
How Distributed Transactions Keep Money Transfers Consistent Without Locks
Architect
Architect
Jan 9, 2016 · Backend Development

Ensuring Data Consistency: Local Transactions, Distributed Two‑Phase Commit, and Message‑Queue Solutions

The article explains how to maintain data consistency when updating related tables by using local transactions for single‑node databases, distributed two‑phase commit for multi‑node systems, and reliable message‑queue patterns—including deduplication techniques—to avoid the performance pitfalls of traditional distributed transactions.

Data ConsistencyMessage Queuetwo-phase commit
0 likes · 10 min read
Ensuring Data Consistency: Local Transactions, Distributed Two‑Phase Commit, and Message‑Queue Solutions
Java High-Performance Architecture
Java High-Performance Architecture
Dec 23, 2015 · Backend Development

Ensuring Safe Redis Queues with RPOPLPUSH and Blocking Commands

Redis lists enable simple message queues, but using LPOP/RPOP can lose messages if a consumer crashes; employing the atomic RPOPLPUSH (or its blocking BRPOPLPUSH) command safeguards delivery, and choosing blocking over non‑blocking operations reduces wasted polling and improves resource efficiency.

Blocking CommandsMessage QueueRPOPLPUSH
0 likes · 4 min read
Ensuring Safe Redis Queues with RPOPLPUSH and Blocking Commands
dbaplus Community
dbaplus Community
Nov 24, 2015 · Backend Development

Open‑Source vs Commercial Message Queues: Features, Performance & Ops Insights

This article examines the rise of cloud‑native architectures, explains core concepts of Message Oriented Middleware, compares JMS and AMQP protocols, evaluates major commercial and open‑source queue products across functionality, operations management, clustering, high‑availability, stability and extensions, and presents detailed performance test results for point‑to‑point and publish/subscribe modes.

Message QueueOpen Sourcecommercial
0 likes · 20 min read
Open‑Source vs Commercial Message Queues: Features, Performance & Ops Insights
21CTO
21CTO
Nov 16, 2015 · Cloud Computing

How JD.com Scales Storage, Caching, and Messaging with Its Own Cloud Platform

This article explains how JD.com’s three‑layer cloud architecture—storage, middleware, and elastic compute—addresses challenges of massive unstructured data, ever‑growing caches, high‑volume messaging, and rapid service deployment using home‑grown systems like JFS, Jimdb, JMQ, and JSF.

CachingCloud ComputingElastic Compute
0 likes · 11 min read
How JD.com Scales Storage, Caching, and Messaging with Its Own Cloud Platform
21CTO
21CTO
Nov 13, 2015 · Backend Development

Optimizing Broker Restarts and Minimizing File Reads in EQueue

This article explains how EQueue handles broker restarts by scanning and initializing chunk files, introduces memory‑based caching strategies to avoid frequent file reads, and outlines message deletion, querying, consumer offset storage, and queue management techniques for high‑performance backend systems.

EQueueMemory CachingMessage Queue
0 likes · 22 min read
Optimizing Broker Restarts and Minimizing File Reads in EQueue
21CTO
21CTO
Nov 13, 2015 · Backend Development

How I Reengineered EQueue to Use File-Based Persistence for Faster Messaging

The article details the author's multi‑month effort to replace SQL Server persistence in the open‑source EQueue message queue with a high‑performance local file storage solution, covering the motivations, design considerations, chunked binary file format, write‑and‑read mechanisms, and flushing strategies.

Backend DevelopmentCEQueue
0 likes · 17 min read
How I Reengineered EQueue to Use File-Based Persistence for Faster Messaging
21CTO
21CTO
Oct 29, 2015 · Backend Development

Scaling Sina's News Comment System: From 3.0 to 5.0 – Key Backend Lessons

This article chronicles the evolution of Sina's news comment platform from a single‑server C++/MySQL prototype to a multi‑node, asynchronous, Python‑based architecture, highlighting the caching, sharding, and queueing techniques that enabled the system to survive massive traffic spikes without downtime.

Backend ArchitectureCachingMessage Queue
0 likes · 21 min read
Scaling Sina's News Comment System: From 3.0 to 5.0 – Key Backend Lessons
21CTO
21CTO
Sep 14, 2015 · Backend Development

Why Apache Kafka Beats Traditional Message Queues: Architecture, Code, and Performance

This article explains Apache Kafka's distributed publish‑subscribe design, core components, storage model, ZooKeeper coordination, performance benchmarks against ActiveMQ and RabbitMQ, and provides Java producer and consumer code examples for building high‑throughput messaging applications.

Apache KafkaDistributed MessagingMessage Queue
0 likes · 16 min read
Why Apache Kafka Beats Traditional Message Queues: Architecture, Code, and Performance
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Sep 14, 2015 · Industry Insights

Why Kafka Dominates Distributed Messaging: Architecture, Features, and Best Practices

This article provides an in‑depth examination of Apache Kafka’s origins, design goals, core concepts such as brokers, topics, partitions, producers and consumers, compares it with other message queues, explains its storage format, configuration options, delivery guarantees, and includes practical Java code examples for partitioning and consumption.

Distributed SystemsJavaKafka
0 likes · 22 min read
Why Kafka Dominates Distributed Messaging: Architecture, Features, and Best Practices
21CTO
21CTO
Sep 10, 2015 · Databases

Keeping Money Transfers Consistent: Local Transactions, 2PC, and Message Queues

To prevent data inconsistencies when transferring funds—like moving money from Alipay to Yu'ebao—the article explores local transactions, the limitations of two-phase commit in distributed systems, and how reliable message queues can achieve eventual consistency without sacrificing performance.

Data ConsistencyMessage Queuedistributed transactions
0 likes · 11 min read
Keeping Money Transfers Consistent: Local Transactions, 2PC, and Message Queues
21CTO
21CTO
Aug 18, 2015 · Fundamentals

How to Build Horizontally Scalable Systems: Lessons from Will Larson

This article distills Will Larson’s insights on designing scalable systems, covering linear capacity growth, redundancy, load‑balancing strategies, multi‑layer caching, cache invalidation, offline processing with message queues, Map‑Reduce integration, and the benefits of a dedicated platform layer.

CachingMessage Queuehorizontal scaling
0 likes · 11 min read
How to Build Horizontally Scalable Systems: Lessons from Will Larson
21CTO
21CTO
Aug 14, 2015 · Backend Development

Ensuring Data Consistency: From Local Transactions to Distributed 2PC and Message Queues

This article explores how to maintain data consistency across services by using local transactions, two‑phase commit distributed transactions, and reliable message‑queue patterns, illustrating each method with an Alipay‑to‑YuEBao transfer example and discussing their trade‑offs.

Data ConsistencyDistributed SystemsMessage Queue
0 likes · 11 min read
Ensuring Data Consistency: From Local Transactions to Distributed 2PC and Message Queues
Meituan Technology Team
Meituan Technology Team
Jan 14, 2015 · Big Data

Kafka File Storage Mechanism and Architecture

Kafka stores each topic as partitions that are divided into sequential segment files containing paired .log data and .index files, using global offsets and sparse memory‑mapped indexes to enable fast offset‑based lookups, efficient deletions, and minimal disk I/O in real‑world deployments.

KafkaMessage QueuePartition
0 likes · 9 min read
Kafka File Storage Mechanism and Architecture
ITPUB
ITPUB
Jan 9, 2015 · Databases

Inside Alibaba’s DRDS: How Distributed Databases Power Double‑11

This interview with Alibaba’s DRDS expert Shen Xun reveals how the distributed relational database service evolved from an internal tool to a cloud‑native solution, detailing its architecture, scalability advantages, middleware ecosystem, and real‑world performance during massive events like Double‑11.

Alibaba CloudDRDSMessage Queue
0 likes · 18 min read
Inside Alibaba’s DRDS: How Distributed Databases Power Double‑11
Nightwalker Tech
Nightwalker Tech
Jan 4, 2015 · Backend Development

Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices

This article surveys the architecture of long‑connection push systems for internet apps, distinguishes connection types, outlines client and server handling strategies, reviews mainstream backend solutions, and shares practical insights on security, API design, operations, queue services, debugging, and NoSQL usage.

Backend ArchitectureDebuggingMessage Queue
0 likes · 32 min read
Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices
MaGe Linux Operations
MaGe Linux Operations
Oct 4, 2014 · Backend Development

Which Notification Mechanism Is Best for High‑Concurrency Message Queues?

This article reviews common notification mechanisms—signal, socket, FIFO, pipe, and eventfd/signalfd—used in high‑performance, lock‑free shared‑memory message queues, comparing their advantages, drawbacks, and suitability for different workload scenarios, and explains why kernel involvement can affect performance and when to prefer each method.

LinuxMessage Queuehigh concurrency
0 likes · 3 min read
Which Notification Mechanism Is Best for High‑Concurrency Message Queues?