Tagged articles
ordering
29 articles · Page 1 of 1
The article explains why Java concurrency is difficult by showing that two threads each incrementing an int ten thousand times may not produce twenty thousand, then explores the motivations for multithreading, the differences between concurrency and parallelism, and the three core challenges of visibility, atomicity, and ordering.
ConcurrencyJavaMultithreading
0 likes · 23 min read

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.
IdempotencyKafkaMessage Queue
0 likes · 28 min read

The article explains how moving non‑critical actions in a high‑traffic e‑commerce order flow to a task queue separates core work from optional work, solving delivery guarantees, idempotency, backlog management, and ordering challenges while dramatically reducing latency and fault contagion.
Asynchronous ProcessingIdempotencyTask Queue
0 likes · 17 min read

This article presents a detailed, step‑by‑step design of a universal restaurant POS and ordering system covering four‑tier modular architecture, complete business flow, functional breakdown for front‑end ordering, kitchen production, back‑office management, and core infrastructure, plus implementation steps and solutions to common deployment issues.
InventoryLoyaltyPoS
0 likes · 17 min read

This article demystifies Kafka's ordering guarantees, explains the difference between partition‑level, key‑level, and global ordering, and provides a complete, production‑grade guide—including architecture, configuration, code samples, and best‑practice patterns—to achieve reliable ordered processing while maintaining high throughput and scalability.
CDCConsumerIdempotence
0 likes · 35 min read

This article examines why message queue ordering failures can corrupt data and cause outages, explains four root causes such as concurrent consumption and partitioning, and presents four production‑tested high‑availability patterns—including ordered messages, pre‑condition checks, state‑machine driving, and monitoring—to reliably mitigate MQ disorder.
BackendHigh Availabilityordering
0 likes · 9 min read

This article explores the fundamentals of message ordering in distributed message queues, explains why ordering is determined by broker arrival, compares global and partial ordering, and presents practical solutions—from single-partition designs to multi-partition hashing, handling data skew, and safe expansion—plus interview tips.
Consistent HashingKafkaPartitioning
0 likes · 24 min read

This article examines the root causes of message queue disorder in distributed systems, illustrates real‑world impacts such as data loss during migration, and presents concrete mitigation strategies including ordered messaging, pre‑processing checks, state‑machine handling, and monitoring to improve system reliability.
Message Queuedistributed systemsordering
0 likes · 9 min read

The article compares two backend implementations for drag‑and‑drop ordering—using a simple position column (array model) and a doubly linked list with prev_id and sibling_id—detailing their MySQL schemas, update logic, performance trade‑offs, and practical considerations such as pagination and locking.
Drag-and-DropMySQLarray
0 likes · 9 min read

This article examines seven typical messaging scenarios—ordinary, ordered, delayed, transactional, trace, dead‑letter, and priority messages—explaining the problem each solves, the trade‑offs, and concrete implementations in RocketMQ, Pulsar, RabbitMQ and Kafka with code samples.
BackendMessage Queuedead-letter
0 likes · 14 min read

This article explains how ordering issues in message queues like RabbitMQ and Kafka can break MySQL binlog synchronization, illustrates common pitfalls, and offers practical solutions to guarantee correct processing order in high‑throughput backend systems.
KafkaMessage QueueMySQL
0 likes · 5 min read

The article explains how the Java Memory Model addresses concurrency challenges by defining visibility, ordering, and atomicity guarantees through mechanisms such as volatile, synchronized, cache coherence, memory barriers, CAS operations, and happens‑before relationships, enabling correct and portable multi‑threaded programming.
CASConcurrent ProgrammingHappens-Before
0 likes · 25 min read

Combining MySQL LIKE fuzzy search with pagination can push exact‑match rows to later pages, causing duplicate brand entries; this article explains the root cause, demonstrates failing queries, and presents several fixes—including adjusting page size, splitting exact and fuzzy queries, and using CHAR_LENGTH and LOCATE functions for custom ordering.
Paginationchar_lengthfuzzy-search
0 likes · 9 min read

This article explains the Java Memory Model, distinguishes main memory from thread-local memory, and demonstrates how visibility, ordering, and atomicity affect concurrent programs through code examples, volatile and synchronized keywords, double‑checked locking, and the Happens‑Before rules.
ConcurrencyJMMJava
0 likes · 18 min read

This article demonstrates six different ways to use Pandas for grouping and ordering the values in a DataFrame column according to their original occurrence order, providing complete code examples, explanations, and visual results for each method.
PandasPythondata-manipulation
0 likes · 6 min read

Message‑queue middleware such as RabbitMQ, RocketMQ, ActiveMQ, and Kafka introduces challenges like ordering, loss, duplication, back‑pressure and delayed delivery, which can be mitigated by using single‑consumer queues or partitioning, enabling acknowledgments and replication, applying idempotent identifiers, scaling consumers, and employing dead‑letter or scheduling mechanisms.
KafkaMQMessage Queue
0 likes · 21 min read

This article explains how to achieve ordered message processing by coordinating both producers and consumers, covering the differences between RabbitMQ's simple queue ordering and Kafka's partition-based approach, and offering practical techniques for global and partial ordering.
ConsumerKafkaRabbitMQ
0 likes · 5 min read

This article explains Java thread safety by defining it, breaking down atomicity, visibility, and ordering, illustrating core concepts with AtomicInteger and AtomicStampedReference examples, and detailing the underlying CAS mechanisms, JMM rules, and the ABA problem.
CASConcurrencyJava
0 likes · 10 min read

This article explains the Java memory model, how variables are stored in main and working memory, and why concurrency issues like dirty reads, non‑atomic operations, and instruction reordering occur, while detailing the roles of volatile, synchronized, locks, and atomic classes in ensuring visibility, ordering, and atomicity.
ConcurrencyJavaatomicity
0 likes · 21 min read

This article provides a comprehensive overview of RocketMQ, covering its architecture, how it handles ordered and duplicate messages, transaction processing, producer and consumer mechanisms, storage design, subscription models, and practical best‑practice recommendations for building reliable distributed messaging systems.
DuplicationMessage QueueRocketMQ
0 likes · 23 min read

This article breaks down the Java Memory Model, detailing how atomicity, visibility, and ordering work in multithreaded programs, illustrating the impact of instruction reordering, and showing how synchronized, volatile, and happens‑before rules ensure correct concurrent behavior.
ConcurrencyHappens-BeforeJava
0 likes · 13 min read

The article analyzes a common interview question about guaranteeing message ordering in message‑queue systems, explains why order matters using MySQL binlog and MQ examples, illustrates scenarios where ordering breaks in RabbitMQ and Kafka, and proposes concrete architectural solutions.
BackendInterviewKafka
0 likes · 5 min read

This article explores how CPU, memory, and I/O speed differences create concurrency bugs, detailing the three core issues of visibility, atomicity, and ordering in Java's memory model and showing practical code examples and solutions.
Javaatomicitymemory model
0 likes · 11 min read

This article explains the stringent reliability requirements of instant messaging—ordered delivery, low latency, no loss, and deduplication—analyzes causes of disorder such as multi‑process and multi‑thread architectures, and presents practical solutions including hash‑based routing, sequential IDs, push‑pull mechanisms, ACK optimization, and distributed ID generation.
Message Reliabilitybackend designdeduplication
0 likes · 9 min read

This article explains why maintaining message order is critical, describes common scenarios that cause ordering problems in RabbitMQ and Kafka, and presents practical strategies such as queue partitioning, single‑consumer designs, and internal memory queues to guarantee ordered consumption.
KafkaMessage QueueRabbitMQ
0 likes · 5 min read

This article explains the Java volatile keyword, covering its memory‑visibility and ordering guarantees, how it interacts with the Java Memory Model, why it does not ensure atomicity, and demonstrates typical interview‑style examples and code snippets such as flag signaling and double‑checked locking.
ConcurrencyJavaatomicity
0 likes · 16 min read

This article explains RocketMQ's core features—including ordered and duplicate message handling, transaction messages, producer and consumer mechanisms, storage architecture, indexing, subscription models, and practical best‑practice recommendations—while providing code examples and design insights for building scalable, high‑throughput distributed messaging systems.
DuplicationJavaRocketMQ
0 likes · 23 min read

This article shares Qunar's practical experiences with message-driven architecture, detailing consumer handling of duplicate messages, ordering, concurrency control, asynchronous processing, and batch strategies, and presents concrete solutions such as idempotent checks, deduplication tables, versioning, and QMQ's built‑in executors.
Concurrencyasynchronous ackbatch processing
0 likes · 18 min read

The article explains how Guava helps Java developers avoid null-related bugs, enforce method preconditions, replace cumbersome Object methods with utilities like Optional, Objects, and Ordering, and provides concise patterns for exception propagation using Throwables, all illustrated with clear code examples.
GuavaJavaOptional
0 likes · 18 min read
