BestHub
Sign in
Tagged articles

ZooKeeper

383 articles · Page 2 of 4
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Oct 27, 2022 · Backend Development

Understanding Kafka: Architecture, Principles, Features, and Use Cases

This article explains Kafka's distributed publish‑subscribe architecture, detailing its core components, underlying mechanisms with Zookeeper coordination, key features such as high throughput and fault tolerance, and common application scenarios like log collection, user activity tracking, and stream processing.

Distributed MessagingKafkaStreaming
0 likes · 5 min read
Understanding Kafka: Architecture, Principles, Features, and Use Cases
Selected Java Interview Questions
Selected Java Interview Questions
Oct 23, 2022 · Big Data

Building a Cost‑Effective Data Analysis Platform: ClickHouse vs Elasticsearch and Deployment Guide for Zookeeper, Kafka, Filebeat, and ClickHouse

This article compares Elasticsearch and ClickHouse for log analytics, presents cost‑benefit calculations, and provides a step‑by‑step deployment guide for Zookeeper, Kafka, Filebeat, and ClickHouse to build a scalable, low‑cost data analysis platform for SaaS services.

ClickHouseElasticsearchFilebeat
0 likes · 12 min read
Building a Cost‑Effective Data Analysis Platform: ClickHouse vs Elasticsearch and Deployment Guide for Zookeeper, Kafka, Filebeat, and ClickHouse
Tencent Cloud Middleware
Tencent Cloud Middleware
Sep 27, 2022 · Cloud Native

How Tencent Cloud Optimized Apache Pulsar for Million‑Topic Scale

This article details Tencent Cloud's year‑long practical optimizations for Apache Pulsar, covering Ack hole impacts, TTL/Backlog/Retention strategies, delayed‑message handling, Admin API blocking, ZooKeeper and BookKeeper leaks, and multi‑level cache improvements to achieve stable, high‑performance messaging at massive scale.

Apache PulsarBacklogZooKeeper
0 likes · 18 min read
How Tencent Cloud Optimized Apache Pulsar for Million‑Topic Scale
Sohu Tech Products
Sohu Tech Products
Sep 21, 2022 · Backend Development

Understanding Kafka Partition Failover When a Broker Goes Offline

This article analyzes a real‑world Kafka outage caused by killing a broker process, explains why partitions with a replication factor of one lose their leader, and walks through the internal Zookeeper‑based failover mechanism and leader‑election logic that Kafka uses to recover from such failures.

Leader ElectionZooKeepermessaging
0 likes · 10 min read
Understanding Kafka Partition Failover When a Broker Goes Offline
Top Architect
Top Architect
Sep 3, 2022 · Backend Development

Implementing Distributed Locks with Redis, Zookeeper, and etcd

The article explains how to build reliable distributed locks using Redis, Zookeeper, and etcd, describing the essential concepts of mutual exclusion, safety, and liveness, showing code examples, highlighting common issues, and comparing each solution's advantages and drawbacks.

ConcurrencyRedisZooKeeper
0 likes · 6 min read
Implementing Distributed Locks with Redis, Zookeeper, and etcd
Selected Java Interview Questions
Selected Java Interview Questions
Aug 27, 2022 · Backend Development

Deploying a Cost‑Effective ClickHouse‑Based Backend Data Platform: Comparison with Elasticsearch and Step‑by‑Step Setup Guide

This article compares Elasticsearch and ClickHouse for log analytics, presents cost analysis, and provides detailed deployment instructions for Zookeeper, Kafka, Filebeat, and ClickHouse to build a private, high‑performance backend data platform for SaaS services.

ClickHouseElasticsearchFilebeat
0 likes · 12 min read
Deploying a Cost‑Effective ClickHouse‑Based Backend Data Platform: Comparison with Elasticsearch and Step‑by‑Step Setup Guide
Top Architect
Top Architect
Aug 25, 2022 · Backend Development

Building a Custom RPC Spring Starter: Architecture, Principles, and Code Walkthrough

This article explains the fundamentals of remote procedure call (RPC), presents a complete system architecture diagram, and provides a step‑by‑step implementation of a custom rpc‑spring‑starter using Java, Spring, Zookeeper for service registration, Netty for network communication, and dynamic proxy techniques for client‑side invocation.

JavaNettyRPC
0 likes · 18 min read
Building a Custom RPC Spring Starter: Architecture, Principles, and Code Walkthrough
Top Architect
Top Architect
Aug 20, 2022 · Backend Development

Design and Implementation of a Redis‑Based Delayed Queue Service

This article explains the business scenarios that require delayed processing, compares several delay‑queue solutions such as Java's DelayQueue, RocketMQ and RabbitMQ, and then details a custom Redis‑backed delayed‑queue architecture (1.0 and 2.0 versions) with Zookeeper coordination, pull‑job and worker threads for high‑availability and real‑time message delivery.

JavaRedisZooKeeper
0 likes · 8 min read
Design and Implementation of a Redis‑Based Delayed Queue Service
Ops Development Stories
Ops Development Stories
Aug 15, 2022 · Backend Development

Master Apache Dubbo: From Basics to Real‑World RPC Implementation

This article introduces Apache Dubbo, compares it with Eureka, and provides a complete step‑by‑step example—including service interface, implementation, provider and consumer configurations, XML files, and code snippets—plus instructions for installing and using Dubbo‑Admin for monitoring micro‑service deployments.

Apache DubboDubbo-AdminJava
0 likes · 9 min read
Master Apache Dubbo: From Basics to Real‑World RPC Implementation
IT Architects Alliance
IT Architects Alliance
Aug 13, 2022 · Operations

Why ClickHouse Beats Elasticsearch: Performance, Cost, and Deployment Guide

This article compares ClickHouse and Elasticsearch, analyzes cost savings, and provides step‑by‑step deployment instructions for Zookeeper, Kafka, Filebeat, and ClickHouse clusters, including configuration details, troubleshooting tips, and practical code snippets for building a scalable analytics pipeline.

ClickHouseElasticsearchFilebeat
0 likes · 13 min read
Why ClickHouse Beats Elasticsearch: Performance, Cost, and Deployment Guide
Past Memory Big Data
Past Memory Big Data
Aug 9, 2022 · Big Data

Master the Complete Big Data Ecosystem in One Article

This article provides a comprehensive overview of the big data ecosystem, detailing nine core technology categories—from data collection and storage to computation, analysis, scheduling, and underlying infrastructure—along with tool comparisons, selection guidelines to help readers quickly build a complete big data knowledge system.

Data AnalysisData StorageZooKeeper
0 likes · 12 min read
Master the Complete Big Data Ecosystem in One Article
Wukong Talks Architecture
Wukong Talks Architecture
Aug 9, 2022 · Big Data

Kafka Basics: 15 Key Questions and In‑Depth Answers

This comprehensive guide covers Kafka’s core concepts, architecture, Zookeeper role, producer sending modes, partitioning strategies, replica types, message deletion, performance optimizations, consumer models, offset management, and best‑practice recommendations for scaling and ensuring ordered delivery in distributed streaming systems.

PartitioningStreamingZooKeeper
0 likes · 31 min read
Kafka Basics: 15 Key Questions and In‑Depth Answers
IT Architects Alliance
IT Architects Alliance
Aug 3, 2022 · Big Data

Understanding Kafka Architecture: Topics, Partitions, Replication, Log Segmentation, Zero‑Copy, and Zookeeper Integration

This article explains Kafka's core concepts—including topics, partitions and replicas, log segment storage, leader‑follower mechanics, consumer groups, network threading model, zero‑copy I/O, and the essential role of Zookeeper for broker, topic, consumer, and offset management—providing a comprehensive overview for developers and architects.

KafkaStreamingZooKeeper
0 likes · 10 min read
Understanding Kafka Architecture: Topics, Partitions, Replication, Log Segmentation, Zero‑Copy, and Zookeeper Integration
Architect's Guide
Architect's Guide
Jul 19, 2022 · Backend Development

Design and Implementation of a Custom Java RPC Framework

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.

JavaNettyRPC
0 likes · 15 min read
Design and Implementation of a Custom Java RPC Framework
Top Architect
Top Architect
Jul 7, 2022 · Backend Development

Building a Simple Java RPC Framework: Service Registration, Discovery, and Proxy Generation

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).

JavaJavassistNetty
0 likes · 25 min read
Building a Simple Java RPC Framework: Service Registration, Discovery, and Proxy Generation
政采云技术
政采云技术
Jun 30, 2022 · Backend Development

ElasticJob‑Lite Overview and Implementation Details

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.

ElasticJobJavaJob Management
0 likes · 14 min read
ElasticJob‑Lite Overview and Implementation Details
ITPUB
ITPUB
Jun 28, 2022 · Backend Development

Mastering Distributed Locks: Database, Redis, and Zookeeper Strategies

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.

BackendConcurrencyZooKeeper
0 likes · 20 min read
Mastering Distributed Locks: Database, Redis, and Zookeeper Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Jun 27, 2022 · Backend Development

Implementation Principles and Sample Code of RPC (Remote Procedure Call) in Java

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.

NettyRPCSpring
0 likes · 18 min read
Implementation Principles and Sample Code of RPC (Remote Procedure Call) in Java
Ctrip Technology
Ctrip Technology
May 19, 2022 · Backend Development

Design and Implementation of a Scalable Delay Message Service Using Apache BookKeeper

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.

BookKeeperElastic ArchitectureJava
0 likes · 13 min read
Design and Implementation of a Scalable Delay Message Service Using Apache BookKeeper
Tencent Cloud Developer
Tencent Cloud Developer
Apr 28, 2022 · Operations

Mastering ZooKeeper: Installation, Znode Model, Watchers, and Leader Election Explained

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.

Coordination ServiceInstallationLeader Election
0 likes · 32 min read
Mastering ZooKeeper: Installation, Znode Model, Watchers, and Leader Election Explained
IT Architects Alliance
IT Architects Alliance
Apr 24, 2022 · Backend Development

Distributed Locks and Idempotency: Principles, Implementations, and the Cerberus Solution

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.

CerberusGTISJava
0 likes · 31 min read
Distributed Locks and Idempotency: Principles, Implementations, and the Cerberus Solution
Top Architect
Top Architect
Apr 22, 2022 · Backend Development

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS

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.

ConcurrencyJavaRedis
0 likes · 32 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS
Selected Java Interview Questions
Selected Java Interview Questions
Apr 19, 2022 · Backend Development

Implementing Distributed Locks in Java: Database, Redis, and Zookeeper Solutions

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.

BackendConcurrencyZooKeeper
0 likes · 13 min read
Implementing Distributed Locks in Java: Database, Redis, and Zookeeper Solutions
Code Ape Tech Column
Code Ape Tech Column
Apr 16, 2022 · Backend Development

Design and Implementation of a Custom RPC Framework with Spring Boot and Netty

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.

NettyRPCSpring Boot
0 likes · 14 min read
Design and Implementation of a Custom RPC Framework with Spring Boot and Netty
Tencent Cloud Developer
Tencent Cloud Developer
Apr 14, 2022 · Big Data

Understanding Kafka's Transition from ZooKeeper to KRaft: Architecture, Installation, Raft Algorithm, and Common Issues

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.

InstallationKRaftKafka
0 likes · 41 min read
Understanding Kafka's Transition from ZooKeeper to KRaft: Architecture, Installation, Raft Algorithm, and Common Issues
Architecture & Thinking
Architecture & Thinking
Mar 22, 2022 · Backend Development

Mastering Dubbo: Build Simple RPC Services with SpringBoot and Zookeeper

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.

DubboRPCSpringBoot
0 likes · 14 min read
Mastering Dubbo: Build Simple RPC Services with SpringBoot and Zookeeper
Java Backend Technology
Java Backend Technology
Mar 13, 2022 · Backend Development

Why Native Java Locks Fail in Distributed Systems and How Redis & Zookeeper Solve It

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.

RedisZooKeeperdistributed lock
0 likes · 19 min read
Why Native Java Locks Fail in Distributed Systems and How Redis & Zookeeper Solve It
DataFunSummit
DataFunSummit
Feb 18, 2022 · Databases

ClickHouse Usage Guide: Application Scenarios, Table Engine Selection, Development Standards, Cluster Architecture, and Configuration

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.

SQL Best PracticesTable EnginesZooKeeper
0 likes · 22 min read
ClickHouse Usage Guide: Application Scenarios, Table Engine Selection, Development Standards, Cluster Architecture, and Configuration
Java Interview Crash Guide
Java Interview Crash Guide
Feb 14, 2022 · Backend Development

How Does RPC Work? A Deep Dive into Building a Custom Java RPC Framework

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.

JavaNettyRPC
0 likes · 19 min read
How Does RPC Work? A Deep Dive into Building a Custom Java RPC Framework
Architecture Digest
Architecture Digest
Feb 12, 2022 · Backend Development

Understanding RPC Implementation Principles and a Basic Java RPC Framework Example

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.

JavaRPCSpring
0 likes · 19 min read
Understanding RPC Implementation Principles and a Basic Java RPC Framework Example
IT Architects Alliance
IT Architects Alliance
Feb 10, 2022 · Backend Development

Design and Implementation of a Custom RPC Framework

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.

JavaNettyRPC
0 likes · 15 min read
Design and Implementation of a Custom RPC Framework
21CTO
21CTO
Jan 28, 2022 · Backend Development

How Does RPC Work? A Deep Dive into Java RPC Implementation with Netty and Zookeeper

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.

JavaNettyRPC
0 likes · 17 min read
How Does RPC Work? A Deep Dive into Java RPC Implementation with Netty and Zookeeper
Su San Talks Tech
Su San Talks Tech
Jan 27, 2022 · Big Data

Why Kafka 2.8 Is Dropping Zookeeper and What It Means for You

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.

KIP-500KRaftStreaming
0 likes · 9 min read
Why Kafka 2.8 Is Dropping Zookeeper and What It Means for You
Architecture Digest
Architecture Digest
Jan 25, 2022 · Backend Development

Distributed Lock Implementation Approaches in Java: Database, Redis, and Zookeeper

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.

JavaRedisZooKeeper
0 likes · 14 min read
Distributed Lock Implementation Approaches in Java: Database, Redis, and Zookeeper
Top Architect
Top Architect
Jan 15, 2022 · Backend Development

Distributed Lock Implementation Strategies: Database, Redis, and Zookeeper

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.

BackendJavaRedis
0 likes · 15 min read
Distributed Lock Implementation Strategies: Database, Redis, and Zookeeper
Java Interview Crash Guide
Java Interview Crash Guide
Jan 11, 2022 · Backend Development

How to Design and Implement a Custom RPC Framework from Scratch

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.

JavaNettyRPC
0 likes · 16 min read
How to Design and Implement a Custom RPC Framework from Scratch
IT Architects Alliance
IT Architects Alliance
Jan 10, 2022 · Backend Development

How RPC Works: Build a Simple RPC Framework with Spring, Netty, and Zookeeper

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.

JavaNettyRPC
0 likes · 17 min read
How RPC Works: Build a Simple RPC Framework with Spring, Netty, and Zookeeper
High Availability Architecture
High Availability Architecture
Dec 24, 2021 · Backend Development

Understanding Broker‑Side Message Acknowledgment and Cursor Management in Apache Pulsar

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.

Apache PulsarBookKeeperCursor Management
0 likes · 12 min read
Understanding Broker‑Side Message Acknowledgment and Cursor Management in Apache Pulsar
Tencent Cloud Middleware
Tencent Cloud Middleware
Dec 20, 2021 · Backend Development

How Pulsar Brokers Manage Message Acknowledgments and Cursor Gaps

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.

Apache PulsarBookKeeperCursor
0 likes · 15 min read
How Pulsar Brokers Manage Message Acknowledgments and Cursor Gaps
Tencent Cloud Middleware
Tencent Cloud Middleware
Dec 16, 2021 · Operations

Inside ZooKeeper: Source Code Walkthrough, Thread Model, and Real‑World Ops Tips

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.

Distributed CoordinationSource Code AnalysisZooKeeper
0 likes · 20 min read
Inside ZooKeeper: Source Code Walkthrough, Thread Model, and Real‑World Ops Tips
macrozheng
macrozheng
Dec 15, 2021 · Backend Development

Implement Distributed Locks with Spring Integration: Redis & Zookeeper Guide

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.

JavaRedisZooKeeper
0 likes · 7 min read
Implement Distributed Locks with Spring Integration: Redis & Zookeeper Guide
Cloud Native Technology Community
Cloud Native Technology Community
Dec 9, 2021 · Backend Development

Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices

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.

ConcurrencyLuaRedis
0 likes · 31 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
HomeTech
HomeTech
Dec 7, 2021 · Big Data

Flink Task Auto-scaling Design and Implementation

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.

FlinkHDFSZooKeeper
0 likes · 4 min read
Flink Task Auto-scaling Design and Implementation
IT Architects Alliance
IT Architects Alliance
Nov 26, 2021 · Fundamentals

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS

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.

ConcurrencyJavaRedis
0 likes · 34 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS
Tencent Cloud Middleware
Tencent Cloud Middleware
Nov 24, 2021 · Backend Development

Deep Dive into ZooKeeper 3.5.5: Server Startup, Leader Election, and Request Processing

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.

JavaLeader ElectionRequest Processing
0 likes · 22 min read
Deep Dive into ZooKeeper 3.5.5: Server Startup, Leader Election, and Request Processing
Selected Java Interview Questions
Selected Java Interview Questions
Nov 17, 2021 · Backend Development

Implementing Distributed Locks with Redis, Redisson, and Zookeeper in Java

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.

ConcurrencyJavaRedis
0 likes · 14 min read
Implementing Distributed Locks with Redis, Redisson, and Zookeeper in Java
Tencent Cloud Middleware
Tencent Cloud Middleware
Nov 16, 2021 · Fundamentals

Understanding ZooKeeper: Core Concepts, Architecture, and Practical Insights

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.

Leader ElectionZAB ProtocolZnode Data Structures
0 likes · 23 min read
Understanding ZooKeeper: Core Concepts, Architecture, and Practical Insights
IT Architects Alliance
IT Architects Alliance
Nov 15, 2021 · Industry Insights

Why Kafka’s Topic‑Partition Design Powers Scalable Messaging

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.

Consumer GroupKafkaPerformance
0 likes · 11 min read
Why Kafka’s Topic‑Partition Design Powers Scalable Messaging
Architect
Architect
Nov 8, 2021 · Operations

Designing High Availability for Canal Using Zookeeper: Distributed Locks and Watch Mechanism

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.

CanalZooKeeperdistributed lock
0 likes · 13 min read
Designing High Availability for Canal Using Zookeeper: Distributed Locks and Watch Mechanism
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 11, 2021 · Fundamentals

Can Joint Consensus Member Changes Be Simplified to a Single Step?

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.

ConsensusRaftZooKeeper
0 likes · 15 min read
Can Joint Consensus Member Changes Be Simplified to a Single Step?
NiuNiu MaTe
NiuNiu MaTe
Oct 7, 2021 · Backend Development

Mastering Zookeeper: Core Concepts, Architecture, and Leader Election Explained

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.

Distributed CoordinationLeader ElectionWatcher
0 likes · 19 min read
Mastering Zookeeper: Core Concepts, Architecture, and Leader Election Explained
Ops Development Stories
Ops Development Stories
Aug 28, 2021 · Operations

Inside Kafka's Topic Deletion: Code Walkthrough & Process Explained

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.

KafkaScalaTopic Deletion
0 likes · 17 min read
Inside Kafka's Topic Deletion: Code Walkthrough & Process Explained
Programmer DD
Programmer DD
Aug 15, 2021 · Operations

Zookeeper in Action: Config Management, Distributed Locks, Queues & Load Balancing

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.

ZooKeeperconfiguration managementdistributed systems
0 likes · 16 min read
Zookeeper in Action: Config Management, Distributed Locks, Queues & Load Balancing
Top Architect
Top Architect
Aug 10, 2021 · Backend Development

Using Zookeeper for Configuration Management, Distributed Locks, Queues, and Load Balancing in Backend 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.

JavaZooKeeperconfiguration management
0 likes · 15 min read
Using Zookeeper for Configuration Management, Distributed Locks, Queues, and Load Balancing in Backend Systems
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Aug 4, 2021 · Backend Development

Design and Implementation of ylock: A Distributed ReentrantReadWriteLock Framework

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.

Spring BootZooKeeperdistributed lock
0 likes · 24 min read
Design and Implementation of ylock: A Distributed ReentrantReadWriteLock Framework
macrozheng
macrozheng
Jul 30, 2021 · Cloud Native

Choosing the Right Service Registry: Eureka, Zookeeper, Consul, Nacos Explained

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.

CAP theoremConsulEureka
0 likes · 12 min read
Choosing the Right Service Registry: Eureka, Zookeeper, Consul, Nacos Explained
Senior Brother's Insights
Senior Brother's Insights
Jul 28, 2021 · Operations

How Zookeeper Prevents Split‑Brain: Inside Quorum‑Based Leader Election

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.

Leader ElectionZooKeepercluster-management
0 likes · 13 min read
How Zookeeper Prevents Split‑Brain: Inside Quorum‑Based Leader Election
dbaplus Community
dbaplus Community
Jul 25, 2021 · Backend Development

Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls

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.

LuaRedisZooKeeper
0 likes · 40 min read
Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls
DeWu Technology
DeWu Technology
Jul 9, 2021 · Cloud Computing

Common Service Registration Centers: Principles and Comparisons

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.

ConsulEurekaNacos
0 likes · 20 min read
Common Service Registration Centers: Principles and Comparisons
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 9, 2021 · Backend Development

Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases

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.

Distributed CoordinationLeader ElectionZAB Protocol
0 likes · 8 min read
Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases
Big Data Technology & Architecture
Big Data Technology & Architecture
Jun 24, 2021 · Big Data

Comprehensive Overview of HBase Architecture, Design, and Operations

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.

Columnar DatabaseHBaseHDFS
0 likes · 30 min read
Comprehensive Overview of HBase Architecture, Design, and Operations
IT Architects Alliance
IT Architects Alliance
Jun 17, 2021 · Operations

What Makes a System Highly Available? 6 Proven Architecture Patterns

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.

LVSNginxZooKeeper
0 likes · 7 min read
What Makes a System Highly Available? 6 Proven Architecture Patterns
ITPUB
ITPUB
Jun 11, 2021 · Backend Development

Is Redis Distributed Lock Really Safe? Uncovering Redlock, Pitfalls, and Best Practices

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.

Lua scriptZooKeeperdistributed lock
0 likes · 35 min read
Is Redis Distributed Lock Really Safe? Uncovering Redlock, Pitfalls, and Best Practices
Tencent Cloud Developer
Tencent Cloud Developer
May 27, 2021 · Big Data

An Introduction to Kafka: Architecture, Core Components, Service Governance, Performance Optimizations, and Installation Guide

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.

Distributed MessagingInstallationKafka
0 likes · 11 min read
An Introduction to Kafka: Architecture, Core Components, Service Governance, Performance Optimizations, and Installation Guide
Java Interview Crash Guide
Java Interview Crash Guide
May 20, 2021 · Backend Development

Eureka vs Zookeeper vs Consul vs Nacos: Which Service Registry Wins?

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.

CAP theoremConsulEureka
0 likes · 12 min read
Eureka vs Zookeeper vs Consul vs Nacos: Which Service Registry Wins?
IT Architects Alliance
IT Architects Alliance
May 11, 2021 · Big Data

Demystifying Kafka: Core Concepts of Topics, Partitions, and Architecture

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.

Consumer GroupKafkaStreaming
0 likes · 6 min read
Demystifying Kafka: Core Concepts of Topics, Partitions, and Architecture
macrozheng
macrozheng
May 8, 2021 · Big Data

Why Kafka 2.8 Drops Zookeeper: Architecture, Challenges, and KIP‑500

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.

KIP-500KRaftKafka
0 likes · 10 min read
Why Kafka 2.8 Drops Zookeeper: Architecture, Challenges, and KIP‑500
Architect's Tech Stack
Architect's Tech Stack
May 7, 2021 · Backend Development

Kafka 2.8 Introduces KRaft: Removing ZooKeeper with an Internal Quorum Controller

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.

KRaftKafkaZooKeeper
0 likes · 4 min read
Kafka 2.8 Introduces KRaft: Removing ZooKeeper with an Internal Quorum Controller
Sohu Tech Products
Sohu Tech Products
May 5, 2021 · Big Data

Kafka Architecture and Implementation Principles – Part 2

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.

KafkaZooKeeper
0 likes · 17 min read
Kafka Architecture and Implementation Principles – Part 2
Programmer DD
Programmer DD
Apr 30, 2021 · Big Data

Kafka 2.8.0 Release: Say Goodbye to ZooKeeper with Raft Metadata Mode

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.

KafkaRaftStreaming
0 likes · 5 min read
Kafka 2.8.0 Release: Say Goodbye to ZooKeeper with Raft Metadata Mode
Top Architect
Top Architect
Apr 26, 2021 · Backend Development

Zookeeper Overview: Installation, Features, and Theory for High‑Concurrency Distributed Systems

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.

Coordination ServiceHigh ConcurrencyZooKeeper
0 likes · 14 min read
Zookeeper Overview: Installation, Features, and Theory for High‑Concurrency Distributed Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 19, 2021 · Backend Development

Mastering Distributed Systems: CAP, Redis, Zookeeper, Kafka and More

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.

KafkaRedisZooKeeper
0 likes · 34 min read
Mastering Distributed Systems: CAP, Redis, Zookeeper, Kafka and More