分布式锁原理与实现

// 获取锁 SETNX + 过期时间
public boolean lock(String lockKey, String requestId, int expireTime) {
    // 使用SETNX命令尝试获取锁
    // SET key value NX PX milliseconds
    String result = jedis.set(lockKey, requestId, SetParams.setParams().nx().px(expireTime));
    return "OK".equals(result);
}

// 释放锁 Lua脚本保证原子性
public boolean unlock(String lockKey, String requestId) {
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then "
                  + "return redis.call('del', KEYS[1]) "
                  + "else return 0 end";
    Object result = jedis.eval(script, 
                              Collections.singletonList(lockKey),
                              Collections.singletonList(requestId));
    return Long.valueOf(1L).equals(result);
}
                        

// 创建分布式锁
public class ZookeeperDistributedLock {
    private ZooKeeper zk;
    private String lockPath;
    private String currentNode;
    private CountDownLatch connectedLatch = new CountDownLatch(1);
    
    // 获取锁
    public boolean lock() throws Exception {
        // 创建临时顺序节点
        currentNode = zk.create(lockPath + "/lock_", new byte[0], 
                                ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                                CreateMode.EPHEMERAL_SEQUENTIAL);
        
        // 获取所有子节点
        List children = zk.getChildren(lockPath, false);
        Collections.sort(children); // 按照顺序排序
        
        // 如果是第一个节点，则获取锁成功
        String firstNode = children.get(0);
        if (currentNode.endsWith(firstNode)) {
            return true;
        }
        
        // 否则监听前一个节点
        String prevNode = firstNode;
        for (String node : children) {
            if (currentNode.endsWith(node)) {
                break;
            }
            prevNode = node;
        }
        
        CountDownLatch latch = new CountDownLatch(1);
        // 监听前一个节点的删除事件
        Stat stat = zk.exists(lockPath + "/" + prevNode, event -> {
            if (event.getType() == Watcher.Event.EventType.NodeDeleted) {
                latch.countDown();
            }
        });
        
        // 如果前一个节点不存在，说明已经释放，获取锁成功
        if (stat == null) {
            return true;
        }
        
        // 等待前一个节点释放锁
        latch.await();
        return true;
    }
    
    // 释放锁
    public void unlock() throws Exception {
        if (currentNode != null) {
            zk.delete(currentNode, -1);
            currentNode = null;
        }
    }
}
                        

// 方法1：基于唯一索引
public boolean lock(String lockKey, String requestId, long expireTime) {
    try {
        // 创建一个包含唯一键约束的记录
        String sql = "INSERT INTO distributed_lock(lock_key, request_id, expire_time) VALUES(?, ?, ?)";
        int inserted = jdbcTemplate.update(sql, lockKey, requestId, System.currentTimeMillis() + expireTime);
        return inserted > 0;
    } catch (Exception e) {
        // 插入失败，说明锁已存在
        return false;
    }
}

// 方法2：基于行锁
public boolean lock(String lockKey, String requestId, long expireTime) {
    String sql = "SELECT * FROM distributed_lock WHERE lock_key = ? FOR UPDATE";
    List> result = jdbcTemplate.queryForList(sql, lockKey);
    
    if (result.isEmpty()) {
        // 锁不存在，创建锁
        jdbcTemplate.update("INSERT INTO distributed_lock(lock_key, request_id, expire_time) VALUES(?, ?, ?)", 
                          lockKey, requestId, System.currentTimeMillis() + expireTime);
        return true;
    } else {
        // 检查锁是否过期
        long expireAt = Long.parseLong(result.get(0).get("expire_time").toString());
        if (System.currentTimeMillis() > expireAt) {
            // 锁已过期，更新锁
            jdbcTemplate.update("UPDATE distributed_lock SET request_id = ?, expire_time = ? WHERE lock_key = ?", 
                              requestId, System.currentTimeMillis() + expireTime, lockKey);
            return true;
        }
    }
    return false;
}

// 释放锁
public boolean unlock(String lockKey, String requestId) {
    String sql = "DELETE FROM distributed_lock WHERE lock_key = ? AND request_id = ?";
    int deleted = jdbcTemplate.update(sql, lockKey, requestId);
    return deleted > 0;
}