分布式锁的实现：Redis和Zookeeper

在分布式系统中，确保数据的一致性和避免并发问题是非常重要的。分布式锁是解决这些问题的关键技术之一。本文将详细介绍如何使用Redis和Zookeeper实现分布式锁，并通过Java代码示例帮助读者理解其实现原理。

1. 分布式锁的基本概念

分布式锁是一种用于协调多个节点对共享资源访问的机制。它确保在任何时刻，只有一个节点能够持有锁并访问资源，从而避免并发冲突。

2. 使用Redis实现分布式锁

Redis是一个高性能的键值存储系统，非常适合用于实现分布式锁。下面是一个使用Redis实现分布式锁的Java示例。

2.1 依赖引入

首先，需要在项目中引入Redis客户端库，例如Jedis。

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

2.2 分布式锁实现

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;
 
public class RedisDistributedLock {
    private static final String LOCK_KEY = "distributed_lock";
    private static final String LOCK_VALUE = "locked";
    private static final int EXPIRE_TIME = 10; // 锁的过期时间，单位秒
 
    private Jedis jedis;
 
    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }
 
    public boolean acquireLock() {
        SetParams params = SetParams.setParams().nx().ex(EXPIRE_TIME);
        String result = jedis.set(LOCK_KEY, LOCK_VALUE, params);
        return "OK".equals(result);
    }
 
    public void releaseLock() {
        jedis.del(LOCK_KEY);
    }
}

2.3 使用示例

public class RedisLockDemo {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        RedisDistributedLock lock = new RedisDistributedLock(jedis);
 
        try {
            if (lock.acquireLock()) {
                System.out.println("Lock acquired, performing critical section operations...");
                // 执行关键操作
            } else {
                System.out.println("Failed to acquire lock.");
            }
        } finally {
            lock.releaseLock();
            jedis.close();
        }
    }
}

3. 使用Zookeeper实现分布式锁

Zookeeper是一个分布式协调服务，也可以用于实现分布式锁。下面是一个使用Zookeeper实现分布式锁的Java示例。

3.1 依赖引入

首先，需要在项目中引入Zookeeper客户端库。

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.7.0</version>
</dependency>

3.2 分布式锁实现

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
 
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
 
public class ZookeeperDistributedLock {
    private static final String LOCK_ROOT = "/locks";
    private static final String LOCK_NODE = LOCK_ROOT + "/lock_";
 
    private ZooKeeper zk;
    private String lockPath;
 
    public ZookeeperDistributedLock(String connectString) throws IOException, InterruptedException {
        CountDownLatch connectedSignal = new CountDownLatch(1);
        zk = new ZooKeeper(connectString, 5000, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    connectedSignal.countDown();
                }
            }
        });
        connectedSignal.await();
    }
 
    public boolean acquireLock() throws KeeperException, InterruptedException {
        lockPath = zk.create(LOCK_NODE, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        while (true) {
            List<String> children = zk.getChildren(LOCK_ROOT, false);
            Collections.sort(children);
            if (lockPath.endsWith(children.get(0))) {
                return true;
            } else {
                int index = Collections.binarySearch(children, lockPath.substring(LOCK_ROOT.length() + 1));
                String previousLockPath = LOCK_ROOT + "/" + children.get(index - 1);
                final CountDownLatch latch = new CountDownLatch(1);
                zk.exists(previousLockPath, new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        if (event.getType() == Event.EventType.NodeDeleted) {
                            latch.countDown();
                        }
                    }
                });
                latch.await();
            }
        }
    }
 
    public void releaseLock() throws KeeperException, InterruptedException {
        if (lockPath != null) {
            zk.delete(lockPath, -1);
            lockPath = null;
        }
    }
 
    public void close() throws InterruptedException {
        zk.close();
    }
}

3.3 使用示例

public class ZookeeperLockDemo {
    public static void main(String[] args) {
        try {
            ZookeeperDistributedLock lock = new ZookeeperDistributedLock("localhost:2181");
            try {
                if (lock.acquireLock()) {
                    System.out.println("Lock acquired, performing critical section operations...");
                    // 执行关键操作
                } else {
                    System.out.println("Failed to acquire lock.");
                }
            } finally {
                lock.releaseLock();
                lock.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 结论

通过上述示例，我们展示了如何使用Redis和Zookeeper实现分布式锁。这两种方法各有优劣，选择哪种方法取决于具体的应用场景和需求。