Java分布式锁如何实现

什么是分布式锁

分布式锁是一种用于多个进程或节点之间协调访问共享资源的机制。在分布式系统中，由于不同的节点运行在不同的进程或服务器上，因此无法通过常规的锁机制来控制多个节点对共享资源的访问。分布式锁的目标是在分布式环境中实现互斥访问，以确保在任意时刻只有一个节点能够对共享资源进行操作，从而避免竞态条件和数据不一致性。

分布式锁实现的要求

实现一个高效可靠的分布式锁需要满足以下要求：

1. 互斥性：在任意时刻只能有一个节点获取到锁。
2. 可重入性：同一个节点可以多次获取同一个锁，避免死锁。
3. 容错性：当持有锁的节点发生故障时，能够自动释放锁，避免死锁。
4. 高可用性：在多个节点竞争锁的情况下，能够快速公平地选择一个节点获得锁。
5. 性能：锁的获取和释放操作需要尽量高效，不影响正常业务的执行。

分布式锁的实现方式

常见的分布式锁的实现方式有以下几种：

1. 基于数据库

可以使用数据库的事务和唯一约束来实现分布式锁。具体实现方式可以通过向数据库插入唯一标识符作为锁的持有者，其他节点在获取锁时发现已存在对应标识符的记录时则获取失败。在释放锁时，删除对应的记录即可。

CREATE TABLE `distributed_lock` (
  `lock_key` varchar(128) NOT NULL,
  PRIMARY KEY (`lock_key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

// 获取锁
BEGIN;
SELECT * FROM `distributed_lock` WHERE `lock_key` = 'key' FOR UPDATE;
INSERT INTO `distributed_lock` (`lock_key`) VALUES ('key');
COMMIT;

// 释放锁
BEGIN;
DELETE FROM `distributed_lock` WHERE `lock_key` = 'key';
COMMIT;

2. 基于缓存

利用分布式缓存系统的原子性操作特性，如Redis的SETNX命令，可以实现分布式锁。具体实现方式可以通过在缓存中存储一个锁的标识符，其他节点在获取锁时尝试设置相同的标识符，若设置成功则获取到锁，否则获取失败。在释放锁时，删除对应的标识符即可。

// 获取锁
boolean acquireLock(String key, String value, long expireTime) {
    Boolean result = redisTemplate.execute((RedisCallback) connection -> {
        JedisCommands commands = (JedisCommands) connection.getNativeConnection();
        return commands.set(key, value, "NX", "PX", expireTime);
    });
    return result != null && result;
}

// 释放锁
boolean releaseLock(String key, String value) {
    String oldValue = redisTemplate.execute((RedisCallback) connection -> {
        JedisCommands commands = (JedisCommands) connection.getNativeConnection();
        return commands.get(key);
    });
    if (oldValue != null && oldValue.equals(value)) {
        return redisTemplate.delete(key);
    }
    return false;
}

3. 基于ZooKeeper

ZooKeeper是一个分布式协调服务，可以利用其有序临时节点的特性来实现分布式锁。具体实现方式可以通过创建一个有序的临时节点，并观察前一个节点。当节点创建成功时，判断自己是否为最小节点，若是则获取到锁，否则等待前一个节点被删除后再次尝试获取锁。在释放锁时，删除对应的临时节点即可。

// 获取锁
boolean acquireLock(CuratorFramework client, String path) throws Exception {
    String node = client.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path);
    return waitUntilLockAcquired(client, node);
}

boolean waitUntilLockAcquired(CuratorFramework client, String node) throws Exception {
    while (true) {
        List children = client.getChildren().forPath(node.substring(0, node.lastIndexOf('/')));
        Collections.sort(children);
        String currentNode = node.substring(node.lastIndexOf('/') + 1);
        if (children.indexOf(currentNode) == 0) {
            return true;
        } else {
            String previousNode = children.get(children.indexOf(currentNode) - 1);
            CountDownLatch latch = new CountDownLatch(1);
            NodeCache nodeCache = new NodeCache(client, node.substring(0, node.lastIndexOf('/')) + "/" + previousNode);
            nodeCache.getListenable().addListener(() -> latch.countDown());
            nodeCache.start(true);
            latch.await();
        }
    }
}

// 释放锁
void releaseLock(CuratorFramework client, String path) throws Exception {
    client.delete().deletingChildrenIfNeeded().forPath(path);
}

分布式锁的总结

分布式锁是一种用于解决多个节点并发访问共享资源的问题的机制。在实现分布式锁时，需要考虑互斥性、可重入性、容错性、高可用性和性能等要求。常见的实现方式包括基于数据库、基于缓存和基于ZooKeeper等。选择合适的实现方式需要根据具体的业务需求、可靠性要求和性能要求来决定。