Java后端中的分布式锁机制：基于数据库、Redis与Zookeeper的实现

微赚淘客机器人开发者联盟@聚娃科技

于 2024-10-01 07:15:00 发布

阅读量120

点赞数 2

文章标签：分布式数据库 java-zookeeper

本文链接：https://blog.csdn.net/java666668888/article/details/142319065

版权

Java后端中的分布式锁机制：基于数据库、Redis与Zookeeper的实现

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们聊一下在Java后端中如何实现分布式锁，主要围绕基于数据库、Redis以及Zookeeper的几种实现方式展开探讨。在分布式系统中，分布式锁是保障多节点并发操作的一种关键手段，避免资源竞争引发的数据不一致问题。

一、基于数据库的分布式锁

在Java后端项目中，基于数据库的分布式锁是最简单的方式之一，通常使用数据库中的表记录来实现分布式锁。核心思想是通过对数据库表中某一行的唯一标识字段进行加锁来达到互斥访问的目的。

我们可以通过以下SQL语句实现分布式锁的获取：

INSERT INTO distributed_lock (lock_name, lock_value) 
VALUES ('lock_key', 'lock_value')
ON DUPLICATE KEY UPDATE lock_value = 'lock_value';

Java代码实现：

package cn.juwatech.lock;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class DatabaseLock {

    private Connection connection;

    public DatabaseLock(Connection connection) {
        this.connection = connection;
    }

    public boolean tryLock(String lockKey, String lockValue) {
        String sql = "INSERT INTO distributed_lock (lock_name, lock_value) VALUES (?, ?) ON DUPLICATE KEY UPDATE lock_value = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, lockKey);
            stmt.setString(2, lockValue);
            stmt.setString(3, lockValue);
            int rowsAffected = stmt.executeUpdate();
            return rowsAffected > 0;
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }
    }

    public void unlock(String lockKey) {
        String sql = "DELETE FROM distributed_lock WHERE lock_name = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, lockKey);
            stmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

基于数据库的锁实现简单，依赖于数据库的事务机制和唯一约束，但它的性能往往受数据库性能的限制，适用于并发不高的场景。

二、基于Redis的分布式锁

Redis作为一个高性能的内存数据库，因其单线程的特性和较高的性能，常被用于实现分布式锁。我们可以通过SET命令设置带有过期时间的键值对，并确保其原子性。

Redis提供的命令如下：

SET lock_key lock_value NX PX 30000

这个命令表示如果lock_key不存在则设置它，且锁的有效期为30秒。NX表示只有在键不存在时才能设置成功，PX指定过期时间单位为毫秒。

Java代码实现：

package cn.juwatech.lock;

import redis.clients.jedis.Jedis;

public class RedisLock {

    private Jedis jedis;

    public RedisLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean tryLock(String lockKey, String lockValue, int expireTime) {
        String result = jedis.set(lockKey, lockValue, "NX", "PX", expireTime);
        return "OK".equals(result);
    }

    public void unlock(String lockKey, String lockValue) {
        String script = 
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "return redis.call('del', KEYS[1]) " +
            "else return 0 end";
        jedis.eval(script, 1, lockKey, lockValue);
    }
}

这里使用了jedis.set方法来实现加锁，并通过Lua脚本来保证解锁的原子性，防止误删其他线程加的锁。在分布式环境下，Redis锁非常高效，且因为支持过期时间，可以避免因异常导致的死锁问题。

三、基于Zookeeper的分布式锁

Zookeeper是一个分布式协调服务，它的强一致性特性使其非常适合用于实现分布式锁。通过Zookeeper的有序临时节点，可以确保在分布式环境下锁的排他性。Zookeeper分布式锁的原理是：客户端在指定的目录下创建临时顺序节点，节点序号最小的获得锁。

Java代码实现：

package cn.juwatech.lock;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;

public class ZookeeperLock {

    private ZooKeeper zooKeeper;
    private String lockRoot = "/locks";
    private String lockPath;
    private String currentLock;

    public ZookeeperLock(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public boolean tryLock(String lockKey) throws Exception {
        // 创建临时顺序节点
        currentLock = zooKeeper.create(lockRoot + "/" + lockKey + "_", null,
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

        List<String> children = zooKeeper.getChildren(lockRoot, false);
        Collections.sort(children);

        // 判断当前节点是否是最小的节点
        if (currentLock.equals(lockRoot + "/" + children.get(0))) {
            return true;
        } else {
            // 监听前一个节点的变化
            String previousNode = children.get(Collections.binarySearch(children, currentLock) - 1);
            Stat stat = zooKeeper.exists(lockRoot + "/" + previousNode, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    synchronized (this) {
                        notifyAll();
                    }
                }
            });
            if (stat != null) {
                synchronized (this) {
                    wait();
                }
            }
        }
        return false;
    }

    public void unlock() throws Exception {
        zooKeeper.delete(currentLock, -1);
    }
}