This article presents a comprehensive overview of a hand‑crafted RPC framework built with Spring Boot, Netty, and Zookeeper, covering its core concepts, architecture, custom message protocol, load‑balancing strategies, serialization choices, starter design, deployment steps, and testing procedures.
This article explains the core concepts and implementation steps of a lightweight Java RPC framework, covering RPC definition, service registration and discovery with Zookeeper, client-side dynamic proxies, network transmission using Netty, serialization, compression, and two server‑side proxy generation strategies (reflection and Javassist).
This article provides a comprehensive overview of ElasticJob‑Lite, a distributed scheduling solution for high‑concurrency environments, covering its architecture, ZooKeeper‑based registration and sharding mechanisms, core listener components, key code examples, and the UI console deployment.
This article explains the design and implementation of distributed locks, covering database pessimistic and optimistic locks, various Redis lock patterns, Redisson and RedLock, as well as Zookeeper's lock mechanism, and compares their advantages, drawbacks, and suitable use cases.
This article explains the fundamentals of RPC, describes the components involved in a basic remote call, and provides a complete Java implementation using Spring, custom XML configuration, Netty for network communication, and Zookeeper for service registration and discovery, complete with server and client code examples.
This article explains the fundamentals of RPC, walks through a complete Java implementation using Spring, Netty, and Zookeeper, and provides step‑by‑step code for both the service provider and consumer, including registration, dynamic proxy generation, network communication, and testing.
This article describes how the QMQ delay‑message service was refactored by separating business logic from storage, adopting Apache BookKeeper for high‑availability, zone‑aware disaster recovery, a configurable DNS resolver, a ZooKeeper‑based task coordinator, and a multi‑level sliding‑time‑bucket scheduler to achieve a stateless, elastic architecture.
An online ClickHouse 10-node cluster experienced a distributed DDL task that hung for over 100 hours, blocking subsequent operations; the article explains the FIFO execution model, diagnosis steps, and a workaround using table renaming to unblock the queue, recommending version upgrade.
This comprehensive guide walks you through ZooKeeper's role in distributed systems, detailed installation steps, Znode data structures, watcher mechanisms, ZAB protocol operations, and the FastLeaderElection algorithm, providing practical commands and configuration examples for building reliable coordination services.
This article explains the challenges of mutual exclusion and idempotency in distributed systems, reviews Java concurrency primitives, compares common distributed lock implementations such as Zookeeper, Redis, and Tair, and introduces Cerberus and GTIS as robust solutions for high‑availability and repeatable operations.
This article explains the mutual‑exclusion and idempotency challenges in distributed environments, analyzes multi‑thread and multi‑process solutions, introduces the principles and implementations of distributed locks (including ReentrantLock, synchronized, Zookeeper, Redis, Tair, and the Cerberus framework), and presents GTIS as a reliable idempotency guard.
This article explains the concept of distributed locks, compares three common implementation schemes—database unique indexes, Redis SETNX, and Zookeeper temporary sequential nodes—and provides complete Java code examples for each, along with analysis of re‑entrancy, lock release timing, and single‑point failures.
This article presents a comprehensive overview of designing and implementing a custom RPC framework using Spring Boot and Netty, covering concepts, architecture, service registration with Zookeeper, load balancing, custom message protocol, serialization, handling TCP fragmentation, and various client invocation modes.
The article explains how Kafka 3.x replaces ZooKeeper with the internal KRaft consensus layer, detailing the Raft‑based metadata storage, step‑by‑step KRaft cluster installation and configuration, and covering related concepts such as leader election, consumer‑group rebalancing, reliability settings, and performance optimizations.
This article introduces CIM, a developer‑oriented distributed instant messaging platform, outlines its current features and roadmap, explains its SpringBoot‑Netty‑Redis‑Zookeeper architecture, and provides detailed installation, configuration, and usage instructions with code examples.
This article walks through the fundamentals of Apache Dubbo, covering its service discovery, RPC communication, traffic management, configuration, and deployment architecture, and provides a step‑by‑step SpringBoot implementation of a simple RPC service with Zookeeper registration, including code snippets for provider, consumer, and controller.
This article explains the inventory oversell problem caused by Java's JVM‑local locks in multi‑machine deployments, introduces distributed locks as a solution, and compares practical implementations using Redis (including RedLock and Redisson) and Zookeeper (with Curator), providing code snippets, deployment considerations, and a pros‑cons analysis to guide technology selection.
This article provides a comprehensive guide to building a custom RPC framework, covering core concepts, architecture diagrams, registration with Zookeeper, Netty communication, custom message protocols, serialization, load balancing, handling TCP packet issues, and practical deployment steps with starter modules.
This article explains the concepts of ClickHouse local and distributed tables, why writing directly to distributed tables can be problematic, and how replication, sharding, and the ReplicatedMergeTree engine work together with ZooKeeper to provide high‑availability and scalable query processing.
This comprehensive guide introduces ClickHouse as a high‑performance columnar DBMS, outlines its typical OLAP use cases, explains the four families of table engines with detailed MergeTree variants, provides SQL creation syntax, shares development and write best practices, and describes cluster architecture, Zookeeper role, chproxy, client tools, availability considerations, and key configuration parameters.
This article explains the principles of Remote Procedure Call (RPC), walks through a complete end‑to‑end RPC workflow—including interface definition, service registration, Netty‑based network communication, request/response handling, and client‑side dynamic proxy generation—while providing runnable Java code examples.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow from defining service interfaces and implementations, registering services in a Zookeeper registry, handling network communication with Netty, and generating client‑side proxies using Spring and JDK dynamic proxies, all illustrated with complete Java code examples.
This article presents a detailed overview of a custom Java RPC framework, covering its core concepts, architecture, communication flow, message protocol, load balancing, serialization, handling of TCP packet fragmentation, and practical implementation using Spring Boot, Netty, and Zookeeper, along with deployment instructions.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the definition, basic call flow, service interface design, server registration with Zookeeper, Netty-based network communication, dynamic proxy generation on the client side, and provides complete Java code examples for a working RPC framework.
This article explains the fundamentals of Remote Procedure Call (RPC), walks through the complete request‑response flow, and provides a step‑by‑step Java implementation using Spring, custom XML namespaces, Netty for network communication, and Zookeeper for service registration and discovery.
This article explains how Kafka 2.8 removes its dependency on Zookeeper, describes the roles of brokers, topics, partitions, and the controller in the Zookeeper‑based architecture, and outlines the KIP‑500 upgrade that replaces Zookeeper with a quorum‑based KRaft controller to improve scalability and operational simplicity.
This article explains the concept of distributed locks, compares three implementation methods—database unique indexes, Redis (using SETNX), and Zookeeper—provides detailed SQL table design and Java code examples for acquiring and releasing locks, and discusses reentrancy, lock release timing, and single‑point failure considerations.
This article explains why distributed locks are needed beyond Java's JVM‑level locks, compares three common implementation approaches—database unique indexes, Redis SETNX, and Zookeeper ephemeral sequential nodes—and provides concrete SQL and Java code examples with analysis of re‑entrancy, release timing, and single‑point risks.
This article explains the concepts, architecture, communication flow, and implementation details of a custom RPC framework built with Spring Boot, Netty, and Zookeeper, covering service registration, load balancing, custom message protocols, serialization, TCP handling, and deployment steps.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow—from interface definition and dynamic proxy generation on the client, through service registration in ZooKeeper, to server‑side handling with Spring and Netty—accompanied by complete Java code snippets and configuration examples.
This article explains how Apache Pulsar brokers track consumer acknowledgment using cursors, describes persistent and non‑persistent subscription differences, details cursor metadata stored in ZooKeeper and BookKeeper, and outlines optimizations for handling message gaps, including RangeSet improvements and a new LRU‑based storage design.
This article explains how Apache Pulsar brokers track consumer acknowledgments using cursors, store metadata in ZooKeeper and BookKeeper, handle acknowledgment gaps with range sets, and optimize memory usage through LRU and segmented storage to ensure reliable message delivery.
This article explains the evolution from centralized to distributed architectures, the role of Zookeeper in solving consistency problems, the mechanics and drawbacks of 2‑phase and 3‑phase commits, and key consensus algorithms such as Paxos, Raft, ZAB, as well as CAP and BASE theories that guide practical system design.
This article provides a comprehensive overview of Apache ZooKeeper, covering its purpose, client‑server thread architecture, key source‑code snippets, watch mechanism, performance characteristics of large‑scale clusters, and practical operational strategies for disaster recovery, observer load, GC pauses, and configuration tuning.
Learn how to implement distributed locks in Spring-based applications using Spring Integration, covering Redlock, Apache Curator alternatives, and detailed step-by-step examples for Redis and Zookeeper backends, including configuration, code snippets, testing procedures, and troubleshooting tips for reliable lock management.
This article thoroughly examines how Redis distributed locks work, the pitfalls of simple SETNX‑based locks such as deadlocks and premature expiration, presents robust solutions using expiration, unique identifiers, Lua scripts, discusses the Redlock algorithm and its controversy, compares Zookeeper locks, and offers practical guidance for safe lock usage.
This article presents the design and implementation of Flink task auto‑scaling, covering background, manual and automatic scaling mechanisms, architecture with RescaleCoordinator, persistence via Zookeeper and HDFS, scaling policies for parallelism, CPU and memory, and future plans for fine‑grained and time‑based resource adjustments.
This article details Qunar's implementation of PostgreSQL high‑availability using Patroni, covering solution selection, custom DCS and failover mechanisms, operational impact, comprehensive testing procedures, performance metrics, and future directions for cross‑region HA deployment.
This article explains the challenges of mutual exclusion and idempotency in distributed environments, compares thread‑level and process‑level solutions, describes the principles and typical implementations of distributed locks (Zookeeper, Redis, Tair, Cerberus), and introduces GTIS as a reliable idempotency framework.
This article provides a comprehensive analysis of ZooKeeper 3.5.5 source code, covering the distributed‑mode server startup sequence, leader election algorithm, cluster data synchronization, server role responsibilities, and the request‑processor pipeline, offering practical insights for developers and operators.
This article explains the principles and practical implementations of distributed locks using Redis (SETNX and SET with expiration), Redisson's Java client, and Zookeeper's sequential ephemeral nodes, providing code examples, lock acquisition and release mechanisms, and a comparison of their advantages and drawbacks.
This comprehensive guide introduces ZooKeeper's purpose, core data structures, API commands, watch mechanisms, server roles, leader election, ZAB protocol, observer nodes, storage strategies, session handling, client architecture, and serialization, providing both theoretical background and practical tips for developers and operators.
This article explains Kafka’s core architecture—including topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance tricks like sequential writes and zero‑copy—to show how it achieves high‑throughput, fault‑tolerant messaging for large‑scale systems.
This article explains how to expand a ClickHouse cluster by adding new replica nodes, detailing the use of the internal_replication parameter, configuration steps for ReplicatedMergeTree and MergeTree engines, and verification of data synchronization across replicas.
This article explains how to achieve high availability for Canal by designing a Zookeeper‑based distributed lock and watch mechanism, covering primary‑backup role election, failure detection, thundering‑herd mitigation, fair locking, node types, watcher events, and practical Zookeeper applications such as service registration and configuration management.
This article examines the challenges of Raft’s two‑stage Joint Consensus member changes, explores single‑step alternatives, analyzes ZooKeeper’s approach, and proposes improvements that combine safety with reduced log overhead, offering practical insights for distributed system engineers seeking more efficient reconfiguration methods.
This article provides a comprehensive technical analysis of Kafka’s Controller component, covering its background, core responsibilities, data storage, election process, version‑specific improvements, monitoring techniques, and key source‑code excerpts to help engineers understand and manage Kafka clusters effectively.
This article provides a comprehensive overview of Zookeeper, covering its purpose as a distributed coordination service, data structures, system architecture, ZAB protocol, leader election mechanisms, watcher functionality, key features, request ordering, synchronization methods, and potential consistency issues.
This article details a step‑by‑step, zero‑downtime migration of a Zookeeper cluster supporting ClickHouse from Hong Kong to Singapore, covering background, challenges, dynamic‑config upgrades, expansion, configuration changes, encountered issues, and the final rollout plan.
This article examines the five mainstream service registry centers—Zookeeper, Eureka, Consul, Nacos, and Kubernetes—explaining why a registry is needed, how they work, load‑balancing strategies, and provides practical criteria for choosing the most suitable solution in microservice architectures.
This article demonstrates how Zookeeper can be leveraged in Java applications to centrally manage configuration, implement distributed locks, build a distributed queue, and achieve load balancing across services, providing complete code examples and step‑by‑step explanations for each use case.
This article explains the complete Kafka topic deletion workflow, from the client’s deleteTopics request through Zookeeper node creation, controller coordination, broker StopReplica handling, log renaming, delayed file removal, and final cleanup, while providing code excerpts and practical Q&A for common pitfalls.
This article introduces Zookeeper fundamentals and demonstrates four real‑world scenarios—consistent configuration management, distributed locking, distributed queuing, and service load balancing—complete with Java code samples, workflow diagrams, and step‑by‑step explanations for building reliable distributed systems.
This article explains how Zookeeper can be employed in backend applications for centralized configuration management, implementing distributed locks, building distributed queues, and achieving load balancing, providing detailed Java code examples and step‑by‑step explanations of each use case.
This article explains the differences between thread, process, and distributed locks, describes how distributed locks work using third‑party storage such as Redis or Zookeeper, discusses implementation details, and highlights when and why to use them in backend systems.
This article explains the challenges of distributed locking, compares existing lock services, and details the design, implementation, and monitoring features of the ylock framework, which provides reentrant read‑write locks over Redis and Zookeeper with unified APIs and Spring Boot integration.
This article explains the role of service registry centers in micro‑service architectures, outlines the CAP theorem trade‑offs, compares major solutions such as Eureka, Zookeeper, Consul, and Nacos, and discusses operational considerations like health checks, load balancing, and availability.
This article explains the split‑brain phenomenon in distributed clusters, uses Zookeeper as a case study to illustrate how network partitions can create multiple leaders, and details Zookeeper's majority‑quorum mechanism, node count considerations, and common strategies for avoiding split‑brain scenarios.
This article thoroughly explains why distributed locks are needed, walks through basic Redis lock implementations, exposes deadlock and expiration issues, presents robust solutions with unique IDs and Lua scripts, examines the Redlock algorithm, reviews the Martin‑Antirez debate, and compares Redis with Zookeeper locks.
This guide walks through creating a lightweight service registration and discovery mechanism using Spring Boot 2.2.10, Zookeeper 3.6.2, and Java, covering environment setup, Maven dependencies, configuration files, core Java classes, and a test controller to verify dynamic service lists.
This guide shows how to use Zookeeper 3.6.2 with Spring Boot 2.2.10 to create sequential nodes, implement a distributed ID service in Java, and test concurrent ID generation across 100 threads.
This guide demonstrates how to use Zookeeper with Spring Boot to enable data sharing among multiple JVM processes in a distributed system, covering Maven dependencies, configuration files, and Java code for connection, node watching, and data change handling.
The article compares four popular service registration centers—Eureka, Zookeeper, Consul, and Nacos—by outlining each system’s architecture, core principles, and operational mechanisms, with an in‑depth source‑code‑level examination of Nacos’s pull/push discovery, Raft‑based leader election, and concurrent instance management, and concludes with a comparative table of consistency, availability, and partition‑tolerance characteristics.
This article provides a detailed introduction to Zookeeper, covering its definition as a distributed coordination service, core features such as a hierarchical file system, notification mechanism, and cluster management, various application scenarios, the ZAB protocol, node types, leader election process, distributed lock implementation, and watch mechanism, all illustrated with diagrams.
The article analyzes the limitations of using ZooKeeper for service discovery, compares it with Alibaba's ConfigServer, discusses CAP trade‑offs, scalability, health‑check design, disaster recovery, and provides practical guidance on when to choose alternative registration solutions.
This article provides an in‑depth technical overview of HBase, covering its Bigtable origins, distributed column‑store design, core components such as ZooKeeper, HMaster and RegionServer, data flow, storage formats, row‑key design, bulk loading, SQL integration, indexing, coprocessors, and performance tuning for big‑data environments.
This article explains the essential characteristics of high‑availability architectures—master‑slave failover, load balancing, and horizontal scaling—and reviews six practical solutions including LVS + Keepalive, NGINX, Zookeeper, client‑side strategies, service‑level replication, and middleware approaches.
This comprehensive guide explains why distributed locks are needed, walks through basic Redis lock implementations, reveals common dead‑lock and expiration issues, presents atomic solutions with SET EX NX and Lua scripts, evaluates the Redlock algorithm, examines expert debates, compares Zookeeper locks, and offers practical recommendations for safe usage.
This article explains the limitations of local locks in distributed systems and provides detailed implementations of distributed locks using Redis (SETNX, Lua scripts, Redisson) and ZooKeeper (ephemeral sequential nodes), complete with code examples and best‑practice recommendations.
This guide demonstrates how to deploy Apache Zookeeper on Kubernetes using three approaches—StatefulSet, a custom Operator, and KUDO—covering configuration files, command‑line steps, scaling procedures, and verification, enabling elastic, high‑availability service discovery in cloud‑native environments.
This guide walks you through preparing a CentOS 8 environment, installing JDK, Zookeeper and Kafka, configuring each service with proper data directories and ports, and automating startup using shell scripts for a three‑node Zookeeper cluster and a three‑node Kafka cluster.
Kafka is a high‑throughput distributed publish‑subscribe system that uses brokers, topics, partitions, offsets, producers, consumers, and Zookeeper for metadata and leader election, offering fast sequential disk writes, page‑cache zero‑copy transfers, ISR‑based replication, and includes step‑by‑step installation of JDK, Zookeeper, and Kafka.
This article explains the role of a service registry in micro‑service architectures, compares Zookeeper (CP) and Eureka (AP) in terms of design, consistency, and availability, and provides detailed code and configuration examples for deploying both solutions in a high‑availability cluster.
This article examines Spring Cloud’s four major service‑registry options—Eureka, Zookeeper, Consul, and Nacos—detailing their architectures, CAP characteristics, health‑check mechanisms, load‑balancing strategies, and integration features to help developers choose the most suitable solution for microservice governance.
The article explains how Kafka 2.8 removes its dependency on Zookeeper, detailing Kafka's core concepts, the role of Zookeeper in broker registration, load balancing, and controller election, the operational drawbacks of this coupling, and how KIP‑500 with a Quorum Controller modernizes the architecture.
This article explains how to achieve high availability for Canal servers by using Zookeeper to implement a distributed lock, watch mechanism, and fair scheduling, while also addressing thundering‑herd problems and illustrating common Zookeeper applications such as service registry and configuration center.
This article provides a clear, visual walkthrough of Kafka’s fundamental architecture, explaining how producers and consumers interact, the role of topics and partitions, consumer groups, and ZooKeeper’s coordination, helping readers grasp message flow, storage, ordering, and fault‑tolerance in a distributed streaming system.
This article explains how Kafka 2.8 removes its dependency on Zookeeper, describes Kafka's core concepts and its interaction with Zookeeper, outlines the role of the Controller, discusses operational complexities and upgrade paths with KIP‑500, and highlights the benefits of the new KRaft‑based architecture.
Kafka 2.8 replaces the external ZooKeeper dependency with an internal Quorum controller (KRaft), enabling ZooKeeper‑free deployments that reduce resource usage, improve performance, support larger clusters, but currently lack some features such as ACLs, transactions, and partition reassignment, making it unsuitable for production yet.
This article provides an in‑depth, English‑language explanation of Kafka's overall architecture, including the roles of producers, consumers, topics, partitions, replication, Zookeeper coordination, controller election, and the NIO‑based network model, helping readers understand both concepts and practical configuration implications.
Kafka 2.8.0, released on April 19, 2021, introduces the groundbreaking Raft Metadata mode that eliminates the need for ZooKeeper, alongside numerous new features, bug fixes, and enhancements such as API controls for stream threads, SASL_SSL mutual TLS, and IP rate limiting.
This article introduces Zookeeper as a high‑performance coordination service for distributed systems, covering its role in concurrent environments, installation steps on Linux, core characteristics, data model, session and watch mechanisms, and practical usage examples to help readers understand and apply it in backend development.
This comprehensive guide covers core distributed system theories, CAP consistency, transaction protocols, Redis features and persistence, Zookeeper coordination, message queue fundamentals, Kafka performance tricks, and practical solutions for caching, locking, and high‑concurrency scenarios.
This comprehensive guide explains ZooKeeper’s role as a distributed coordination service, covering its consistency guarantees, Znode hierarchy, ZAB protocol, watcher mechanism, ACLs, server roles, data synchronization modes, deployment options, dynamic scaling, and typical use cases such as configuration management, service discovery, leader election, distributed locks and queues.
This article provides a comprehensive, diagram‑driven explanation of Kafka’s architecture, covering producers, consumers, topics, partitions, replication, Zookeeper coordination, controller election, state machines, and the NIO‑based network model, helping readers understand the design philosophy and practical configuration implications.
This article provides a comprehensive tutorial on Zookeeper 3.5.10, covering client and server commands, node attributes, creation, querying, updating, deletion, listing children, checking node status, watcher usage, and detailed access control mechanisms with practical command examples.
This article explains how Zookeeper’s distributed lock mechanisms—including non‑fair, fair, and read‑write locks—can prevent overselling in high‑traffic seckill scenarios, details their advantages and drawbacks, and provides practical Curator‑based Java implementations with code examples.
Apache Kafka 2.8 replaces ZooKeeper with an internal Quorum controller (KRaft), enabling ZooKeeper‑free operation, reducing resource usage, improving performance, and supporting larger clusters while noting that early versions lack some security and management features and are not yet production‑ready.
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.
This guide walks through configuring Spring Boot 2.3.9 with Spring Cloud Hoxton to register services in Zookeeper, set up provider and consumer applications, and achieve client‑side load balancing using Spring Cloud LoadBalancer.
This article provides a comprehensive overview of Zookeeper's cluster deployment, explains the four server states, details the leader election process—including initialization, voting, and decision logic—and presents key source code snippets to help developers understand and implement Zookeeper's high‑availability mechanisms.
Distributed locks ensure exclusive access across multiple servers in high-concurrency scenarios, and this article explains their necessity, illustrates problems with simple locks, and details practical implementations using Redis and Zookeeper, including lock acquisition, release, expiration handling, and avoiding deadlocks.
This article explains the concepts and practical implementations of distributed locks using Redis, Redisson, and ZooKeeper, covering lock acquisition, expiration handling, atomicity, automatic renewal, and code examples for Java developers working in clustered environments.
This article provides a comprehensive overview of Zookeeper, covering its purpose, cluster roles, Znode types, session handling, watcher mechanism, ACL permissions, common use cases, data consistency via the ZAB protocol, leader election, synchronization methods, potential inconsistency scenarios, and a comparison with other service‑registry solutions.
This article explains why ZooKeeper was created, its role in simplifying distributed application development, key characteristics such as high performance, high availability, and consistency, and outlines the fundamental problems it solves in multi‑process coordination across networked systems.
This article explains the fundamentals of distributed locks, compares lock implementations based on asynchronous replication and Paxos protocols, and provides practical Redis and etcd/Zookeeper examples—including exclusive and shared lock mechanisms, code snippets, and usage considerations for reliability and safety.
This article walks through the design and implementation of a Java RPC framework, detailing added serialization options, multiple load‑balancing strategies, client‑side service caching, TCP long‑connection handling with Netty, performance testing, and provides the full source code for replication.
This article introduces Apache ZooKeeper’s core concepts—including its three deployment modes, node roles, hierarchical data model, and common use cases—then provides a step‑by‑step guide to building a ZooKeeper cluster with Docker‑Compose, configuring the environment, and performing basic CLI operations.
This article describes a series of improvements to a Spring‑Boot based Java RPC framework—including support for Protobuf and Kryo serialization, multiple load‑balancing algorithms, client‑side service caching, TCP long‑connection reuse via Netty, and a performance test that reduces request latency by more than tenfold.
This guide walks through setting up a three‑node Zookeeper ensemble, configuring ActiveMQ with replicated LevelDB storage, and starting the services on each host, providing full command‑line steps, configuration snippets, and verification screenshots for a production‑grade deployment.
