Tagged articles
message queues
57 articles · Page 1 of 1
This comprehensive guide breaks down Linux inter‑process communication (IPC) by explaining its core concepts, why it’s needed, and detailing six mechanisms—pipes, named pipes, message queues, shared memory, semaphores/PV operations, signals, and sockets—complete with code samples, diagrams, and real‑world usage scenarios.
IPCLinuxShared Memory
0 likes · 49 min read

Apache Kafka 4.1.0 introduces native queue semantics, a new Streams rebalancing protocol, multi‑version Connect plugins, a revamped consumer‑group protocol, enhanced transaction safety, and numerous client, monitoring, and security improvements, offering a comprehensive upgrade over the 4.0 release.
Kafkadistributed-systemskafka-4.1
0 likes · 6 min read

The article combines a surprising look at XiaoHongShu's record‑breaking graduate salaries with a comprehensive backend interview guide covering Redis advantages and drawbacks, common data structures, persistence and high‑availability, MySQL lock types, optimistic vs. pessimistic locking, message‑queue fundamentals, RabbitMQ vs. Kafka differences, deadlock avoidance, and a sample algorithm question.
Database LocksMySQLRedis
0 likes · 19 min read

This comprehensive guide explores Linux inter‑process communication (IPC), explaining why processes need to communicate, the underlying kernel mechanisms, and detailed coverage of pipes, FIFOs, signals, files, shared memory, message queues, and sockets with practical code examples and real‑world use cases.
IPCLinuxShared Memory
0 likes · 48 min read

This article provides a concise overview of Kafka cluster fundamentals, describing how multiple brokers form a distributed system, the role of topics and partitions for scalability, and illustrating data distribution and replication with a three‑broker example.
Kafkamessage queues
0 likes · 4 min read

This article explains the essential components of a Kafka cluster—including producers, consumers, brokers, Zookeeper, and the KRaft controller—detailing how topics, partitions, and replication enable high‑throughput, scalable, and fault‑tolerant distributed messaging.
Kafkaarchitecturemessage queues
0 likes · 5 min read

The article details G7 EasyFlow's low‑code data synchronization platform, explaining its origins from massive integration demands, its architecture, core features such as high availability, high concurrency, fault‑tolerant mechanisms, low‑code scripting, distributed deployment, and how it streamlines multi‑system data consistency for enterprise customers.
backend developmentdata synchronizationlow-code platform
0 likes · 17 min read

This article explains Kafka's event streaming concept, detailing events and streams, core components such as producers, topics, partitions, consumers, persistence, and typical real‑time data pipeline, event‑driven architecture, stream processing, and log aggregation use cases, highlighting its role as a foundational big‑data infrastructure.
Kafkaevent streamingmessage queues
0 likes · 7 min read

From early 1970s Bell Labs' breakthrough of process isolation to the invention of in‑memory pipes, named pipes, and structured message queues, this article traces the evolution of inter‑process communication, highlighting design motivations, code structures, advantages, limitations, and the performance challenges that drove each innovation.
IPCProcess CommunicationSystems Programming
0 likes · 8 min read

Kafka 4.0 replaces ZooKeeper with the native KRaft (Kafka Raft) consensus layer, simplifying deployment, boosting scalability, cutting latency, and introducing a new incremental consumer rebalance protocol and share‑group model that together reshape how distributed streaming applications are built and operated.
Consumer RebalanceKRaftKafka
0 likes · 9 min read

This article examines the Multi‑Channel Protocol (MCP) for AI agents, comparing its primary communication options—STDIO and Server‑Sent Events—and exploring additional alternatives such as WebSockets, gRPC, and message queues, while offering guidance on selecting the most suitable protocol for various deployment scenarios.
MCPSSEcommunication protocols
0 likes · 11 min read

To address consistency problems in distributed systems, the article explains CAP and BASE trade‑offs, shows how transactional RPC and messaging—using retries, RocketMQ two‑phase commits, Spring @TransactionalEventListener, or a local message log—can ensure atomic updates, and compares their reliability, latency, and performance impacts.
BASE theoryCAP theoremDistributed Consistency
0 likes · 12 min read

This article provides a detailed, step‑by‑step overview of every Linux interprocess communication mechanism—including pipes, signals, files, semaphores, shared memory, message queues, sockets, and Unix domain sockets—complete with concepts, usage scenarios, diagrams, and full code examples.
IPCLinuxPipe
0 likes · 32 min read

The article details Tencent’s updated 15‑month compensation packages for 2025 backend roles, outlines a one‑hour interview covering OS process/thread concepts, sorting algorithms, MySQL storage engines and indexing, Redis data structures, Java collections, and compares RocketMQ with Kafka for reliable messaging.
Interview Preparationdata structuresdatabases
0 likes · 27 min read

This article presents a comprehensive framework for optimizing system components such as databases, caches, message queues, and search engines, covering environment configuration, data structure organization, client‑side usage, and inter‑component collaboration, illustrated with MySQL, Redis, Kafka, and Elasticsearch examples.
CachingSystem Optimizationcomponent tuning
0 likes · 6 min read

This guide explains Linux inter‑process communication (IPC) mechanisms—including anonymous and named pipes, signals, file‑based communication, semaphores, various shared‑memory techniques, message queues, TCP/UDP sockets, and Unix domain sockets—providing concepts, typical use cases, and complete C code examples for each method.
IPCLinuxmessage queues
0 likes · 32 min read

This guide explains the core Linux inter‑process communication mechanisms—including pipes, signals, files, semaphores, shared memory, message queues, sockets, and Unix‑domain sockets—detailing their concepts, typical use‑cases, and providing concise C code examples for each.
IPCLinuxShared Memory
0 likes · 31 min read

This article introduces Linux interprocess communication (IPC), describes the characteristics and usage of unnamed and named pipes, message queues, shared memory, signals, and semaphores, and provides complete C code examples and a producer‑consumer demonstration that combine these mechanisms.
IPCLinuxShared Memory
0 likes · 39 min read

This article explains Kafka's leader election process, partition assignment strategy, distribution policies, file layout, and the evolution of consumer offset storage, providing a comprehensive overview of how Kafka ensures reliable and efficient message handling in a distributed environment.
KafkaLeader ElectionPartition Assignment
0 likes · 5 min read

This article explains asynchronous messaging patterns, compares RabbitMQ and Apache Kafka in terms of architecture, queues, topics, and use cases, and provides guidance on selecting the appropriate platform for different scenarios in modern systems.
Asynchronous MessagingKafkaRabbitMQ
0 likes · 11 min read

This article compares RabbitMQ and Apache Kafka across dimensions such as message ordering, routing, timing, retention, fault handling, scalability, and consumer complexity, and provides practical guidance on which platform is better suited for specific architectural scenarios.
RabbitMQmessage queuesscalability
0 likes · 16 min read

This article explains asynchronous messaging patterns, compares RabbitMQ and Apache Kafka in depth, and provides a step‑by‑step decision guide that highlights their architectural differences, strengths, weaknesses, and suitable use‑cases for modern software systems.
KafkaRabbitMQTechnology Comparison
0 likes · 11 min read

This article provides a comprehensive overview of Apache Kafka, covering its architecture, core concepts such as topics, partitions, and replicas, common operational commands, and practical performance‑tuning tips for high‑throughput, low‑latency streaming workloads.
KafkaOperationsPerformance Tuning
0 likes · 23 min read

This article provides a comprehensive overview of Kafka, covering its overall architecture, key components such as brokers, producers, consumers, topics, partitions, replicas, and ZooKeeper, as well as logical and physical storage mechanisms, producer and consumer workflows, configuration parameters, partition assignment strategies, rebalancing, and the replication model that ensures data reliability.
Data StreamingKafkadistributed systems
0 likes · 18 min read

This guide explains RabbitMQ fundamentals, its core components and four exchange types, and provides step‑by‑step Spring Boot examples—including configuration, code snippets, and testing procedures—to help developers effectively use fanout, headers, direct, and topic exchanges.
AMQPExchange TypesRabbitMQ
0 likes · 10 min read

This article provides a comprehensive overview of Kafka's architecture and fundamental concepts, covering its overall structure, key components such as brokers, producers, consumers, topics, partitions, replicas, leader‑follower synchronization, offset handling, message storage at both logical and physical layers, as well as producer and consumer workflows, partition assignment strategies, rebalancing, log management, zero‑copy I/O, and reliability mechanisms.
Kafkaconsumer groupsdata replication
0 likes · 22 min read

This article explains why achieving data consistency in modern distributed systems is challenging, reviews ACID properties of local databases, discusses the CAP and BASE theorems, examines event ordering mechanisms, and compares practical solutions such as two‑phase commit, XA, local message tables, and MQ‑based transaction models.
BASE theoremCAP theoremData Consistency
0 likes · 19 min read

This article explains how Tencent engineers configure Apache Pulsar for disaster recovery, covering multi‑replica consistency, journal handling, rack‑aware placement, GEO cross‑region replication, dual‑write/dual‑consume setups, and operational lessons for ad and billing scenarios.
Apache PulsarRack Awarenessmessage queues
0 likes · 10 min read

This article introduces Apache Kafka and Apache Pulsar, compares their core features such as publish/subscribe messaging, storage, real‑time pipelines, and stream processing, outlines key characteristics like high throughput, scalability and fault tolerance, and explains fundamental concepts and architecture components unique to each platform.
KafkaPulsarbig data
0 likes · 14 min read

This article demonstrates how to build a real‑time messaging system for a space‑station scenario using RabbitMQ and Spring Boot, covering configuration of direct and fanout exchanges, scheduling updates, one‑to‑one chat, and broadcast messaging with complete Java code examples.
JavaRabbitMQReal-time Messaging
0 likes · 14 min read

This guide walks through setting up Spring Cloud Stream with RabbitMQ, covering supported binders, core components, configuration, code examples for producers and consumers, consumer groups, and message partitioning to build scalable, event‑driven microservices.
JavaRabbitMQSpring Cloud Stream
0 likes · 9 min read

This article provides an in‑depth introduction to Apache Kafka, covering its distributed streaming platform fundamentals, message‑queue models, topic and partition design, broker and cluster roles, producer partitioning logic, reliability guarantees, consumer group assignors, offset management, and performance optimizations such as sequential disk writes and zero‑copy techniques.
Apache Kafkaconsumer groupsdistributed-streaming
0 likes · 25 min read

This article provides a comprehensive overview of Kafka, covering its layered architecture with Zookeeper, core concepts such as topics, partitions and consumer groups, communication workflow, partition selection strategies, rebalancing mechanisms, reliability configurations, replica synchronization, and reasons for moving away from Zookeeper, all explained in clear English.
Kafkaconsumer groupsdistributed systems
0 likes · 19 min read

This article provides an in‑depth technical guide to Apache Kafka, covering its distributed streaming architecture, core concepts such as topics, partitions, brokers, producers and consumers, reliability guarantees, storage mechanisms, configuration parameters, and consumer assignment strategies, supplemented with Java code examples.
Apache KafkaConsumerPartitioning
0 likes · 24 min read

This article explains Kafka’s core design concepts—including the role of a message system, topics, partitions, producers, consumers, consumer groups, replica management, controller coordination with Zookeeper, performance optimizations like sequential writes and zero‑copy, and its network thread model—illustrated with diagrams and code snippets.
Cluster ArchitectureKafkaconsumer groups
0 likes · 12 min read

This article explains the three RabbitMQ exchange patterns—Direct, Fanout, and Topic—detailing how each routes messages, when to use them, and providing visual flowcharts to illustrate their operation in distributed backend systems applications.
Direct ExchangeRabbitMQTopic Exchange
0 likes · 5 min read

This article compares RabbitMQ and Apache Kafka, explaining their core architectures, exchange and routing mechanisms, delivery guarantees, push vs pull models, dead‑letter handling, partitioning, consumer groups, log compaction, and the strengths and limitations of each system for scalable, ordered message processing.
KafkaRabbitMQmessage queues
0 likes · 21 min read

This article explains Kafka's fundamental principles, cluster architecture, data performance techniques such as zero‑copy and log segmentation, resource planning for high‑throughput scenarios, and provides practical operational commands and custom partitioning examples for reliable, high‑availability deployments.
Cluster DeploymentKafkamessage queues
0 likes · 32 min read

Apache Pulsar 2.8.0 introduces transaction support, featuring a Transaction Coordinator, Transaction Buffer, Transaction Log, Transaction ID, and Pending Acknowledge State, with a detailed workflow that ensures exactly‑once semantics for stream processing, contrasting its design with Kafka’s approach.
Apache PulsarKafka ComparisonTransactions
0 likes · 13 min read

This article explains RabbitMQ's core messaging patterns—including simple, work queues, publish/subscribe, routing, topics, RPC, and publisher confirms—along with the four main exchange types, providing practical use‑case examples for each to help developers choose the appropriate pattern for their backend systems.
RabbitMQWork Queuesbackend development
0 likes · 4 min read

This article introduces seven RabbitMQ messaging patterns—Simple, Work Queue, Publish/Subscribe, Routing, Topics, RPC, and Publisher Confirms—explains their typical use cases such as email delivery, order processing, cache synchronization, and provides complete Java code examples for each pattern.
JavaMessaging PatternsRabbitMQ
0 likes · 15 min read

Kafka 2.8 replaces ZooKeeper with an internal Quorum controller (KRaft), allowing users to run Kafka without external coordination, reducing resource usage, improving performance, and supporting larger clusters, while noting that some features like ACLs and partition reassignment are still pending.
Apache KafkaKRaftZooKeeper
0 likes · 4 min read

This article explains the fundamentals of message‑queue middleware, outlines key scenarios such as asynchronous processing, application decoupling, traffic shaping, log handling and messaging, compares popular products like ActiveMQ, RabbitMQ, ZeroMQ and Kafka, and details JMS concepts and programming models.
Asynchronous ProcessingKafkaRabbitMQ
0 likes · 18 min read

This article introduces several Linux interprocess communication mechanisms—including pipes, message queues, shared memory, semaphores, signals, and sockets—explaining their principles, advantages, drawbacks, and typical usage scenarios for developers preparing for system‑level programming or interviews.
IPCLinuxShared Memory
0 likes · 7 min read


ITPUBJun 22, 2020 · Backend Development
This article provides a concise yet comprehensive overview of the backend development technology stack, covering load balancing, microservice ecosystems, RPC frameworks, service discovery, relational and NoSQL databases, caching strategies, message queues, object storage, and search engines, while highlighting practical configurations and real‑world trade‑offs.
Object Storagebackend developmentdatabases
0 likes · 24 min read

This tutorial walks you through installing RabbitMQ on Windows and Linux, configuring it, and using Spring AMQP to implement five fundamental messaging patterns—simple, work, publish/subscribe, routing, and wildcard—complete with code examples and test endpoints.
DockerJavaMessaging Patterns
0 likes · 21 min read

This article introduces Kafka, covering its definition, core concepts such as topics, partitions, offsets, producers and consumers, typical use cases, underlying design principles including message‑partition allocation and retention policies, processing mechanisms, and common troubleshooting questions for real‑world deployments.
Distributed MessagingKafkabig data
0 likes · 7 min read

This article introduces Kafka, explains its core concepts and design principles, outlines typical use cases, and discusses common operational problems and troubleshooting tips for this high‑throughput distributed messaging system.
Kafkabig datadistributed systems
0 likes · 9 min read

This article provides a comprehensive technical guide to Kafka, covering its distributed architecture, producer and consumer workflows, partition and leader management, message delivery semantics, exactly‑once guarantees, transaction handling, file organization, and key configuration parameters.
Kafkabig datamessage queues
0 likes · 18 min read

This article explains Apache Kafka as a distributed streaming platform, detailing its key features, core APIs, topic and log architecture, partitioning, consumer groups, guarantees, and how it serves both messaging and storage roles for real‑time and batch processing in big‑data environments.
Apache Kafkadistributed systemsmessage queues
0 likes · 13 min read

This curated list compiles essential Spring Cloud Stream articles covering quick start, core concepts, consumer groups and partitions, common FAQs, and four detailed failure‑handling strategies, providing developers with a handy reference to master message‑driven microservices.
Spring Cloud Streambackend developmenterror handling
0 likes · 3 min read

This article provides a comprehensive overview of Apache Kafka, explaining its role in real‑time data pipelines and stream processing, describing key concepts such as topics, partitions, logs, producers, consumers, replication, guarantees, and how Kafka functions as both a messaging and storage system.
Consumer APIKafkaProducer API
0 likes · 13 min read

This article explains Apache Kafka’s distributed publish‑subscribe design, its core components, storage model, broker behavior, integration with ZooKeeper, performance comparisons with RabbitMQ and ActiveMQ, and provides a practical example application illustrating producer and consumer APIs.
Apache Kafkabackend developmentmessage queues
0 likes · 17 min read


21CTOJan 8, 2017 · Backend Development
The author announces a forthcoming series on Internet high‑availability architecture, outlining topics such as CAP theory, distributed caching, SOA, message queues, search systems, and real‑world case studies, and invites readers to suggest additional content while promising detailed, valuable guidance for developers and architects.
Cachingdistributed systemsmessage queues
0 likes · 3 min read

Facing over 140 million monthly active users, Weibo evolved from a LAMP stack to a sophisticated third‑generation architecture that separates interface, service, and resource layers horizontally and adds vertical dimensions of business, technology, monitoring, and governance, leveraging Java, SOA, custom RPC, message queues, SSD caching, and a distributed tracing system to ensure high availability and performance.
backend developmentmessage queuesservice architecture
0 likes · 11 min read

The article examines the fundamentals of message‑based distributed architecture, explains core messaging patterns such as Message Channel, Publisher‑Subscriber and Message Router, and provides practical application scenarios, technology‑selection criteria, and challenges for building robust enterprise integration solutions.
Asynchronous ProcessingIntegration PatternsRabbitMQ
0 likes · 32 min read

This article explains how LinkedIn uses Apache Kafka as a high‑throughput, fault‑tolerant messaging backbone, detailing its architecture, message categories, layered replication, audit mechanisms, and the engineering practices that keep billions of daily messages reliable and fast.
KafkaLinkedInbig data
0 likes · 11 min read
