Using Zookeeper for Configuration Management, Distributed Locks, Queues, and Load Balancing in Java

In this tutorial, a senior architect explains several practical applications of Zookeeper in Java, including centralized configuration management, distributed locking, distributed queuing, and service load balancing.

1. Configuration Management

Configuration data such as database connection details can be stored in Zookeeper nodes, allowing multiple servers to read and update the configuration without restarting.

public class CommonConfig implements Serializable {
    // Database connection configuration
    private String dbUrl;
    private String username;
    private String password;
    private String driverClass;
    // getters, setters, constructors, toString() omitted for brevity
}

The management class synchronizes the configuration to Zookeeper:

public class ZkConfigMng {
    private String nodePath = "/commConfig";
    private CommonConfig commonConfig;
    private ZkClient zkClient;
    public CommonConfig initConfig(CommonConfig commonConfig) { ... }
    public CommonConfig update(CommonConfig commonConfig) { ... }
    public void syncConfigToZookeeper() { ... }
}

A client can retrieve the configuration and listen for changes:

public class ZkConfigClient implements Runnable {
    private String nodePath = "/commConfig";
    private CommonConfig commonConfig;
    @Override
    public void run() { ... }
}

2. Distributed Lock

By creating a persistent lock node and temporary sequential child nodes, processes can acquire a lock based on the smallest sequence number.

public class DistributedLock {
    private static class Constant {
        static final String LOCK_NODE = "/distributed_lock";
        static final String CHILDREN_NODE = "/task_";
    }
    private ZkClient zkClient;
    public String getLock() { ... }
    public Boolean acquireLock(String lockName) throws InterruptedException { ... }
    public void releaseLock(String lockName) { zkClient.delete(lockName); }
    public void closeZkClient() { zkClient.close(); }
}

3. Distributed Queue

Using Zookeeper’s temporary sequential nodes, a producer can enqueue messages and a consumer can dequeue them in FIFO order, with blocking behavior when the queue is empty or full.

public interface AppConstant {
    static String ZK_CONNECT_STR = "127.0.0.1:2181";
    static String NODE_PATH = "/mailbox";
    static String CHILD_NODE_PATH = "/mail_";
    static int MAILBOX_SIZE = 10;
}

public class MailProducer implements Runnable, AppConstant { ... }
public class MailConsumer implements Runnable, AppConstant { ... }

4. Load Balancing

Service providers register their IPs as ephemeral nodes under a common service path; consumers subscribe to child changes and select a provider using a simple random algorithm (or any other load‑balancing strategy).

public class ServiceProvider {
    static String NODE_PATH = "/service";
    static String SERVICE_NAME = "/myService";
    private ZkClient zkClient;
    public void registryService(String localIp, Object obj) { ... }
}

public class ServiceConsumer {
    static String NODE_PATH = "/service";
    static String SERVICE_NAME = "/myService";
    private List<String> serviceList = new ArrayList<>();
    private ZkClient zkClient;
    public void subscribeSerivce() { ... }
    public void consume() { int index = new Random().nextInt(serviceList.size()); ... }
}

5. Summary

Zookeeper is a powerful coordination service that can be used for configuration management, distributed locks, queues, service registration, and load balancing, among other scenarios such as naming services and distributed notifications.