首页 > 软件编程 > java > SpringBoot Zookeeper分布式锁

SpringBoot使用Zookeeper实现分布式锁的实现示例

2025-10-22 16:05:27 作者：小猿、

Zookeeper是一个分布式协调服务,非常适合用来实现分布式锁,下面我将介绍如何在Spring Boot项目中集成Zookeeper来实现分布式锁,_springboot实现基于zk的分布式锁

概述

Zookeeper是一个分布式协调服务，非常适合用来实现分布式锁。下面我将介绍如何在Spring Boot项目中集成Zookeeper来实现分布式锁。

1. 添加依赖

首先，在pom.xml中添加必要的依赖：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.7.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>5.2.0</version>
</dependency>

2. 配置Zookeeper连接

在application.properties或application.yml中配置Zookeeper连接信息：

# Zookeeper配置
zookeeper.address=localhost:2181
zookeeper.session-timeout=5000
zookeeper.connection-timeout=5000

3. 创建Zookeeper配置类

@Configuration
public class ZookeeperConfig {

    @Value("${zookeeper.address}")
    private String connectString;

    @Value("${zookeeper.session-timeout}")
    private int sessionTimeout;

    @Value("${zookeeper.connection-timeout}")
    private int connectionTimeout;

    @Bean
    public CuratorFramework curatorFramework() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString(connectString)
                .sessionTimeoutMs(sessionTimeout)
                .connectionTimeoutMs(connectionTimeout)
                .retryPolicy(retryPolicy)
                .build();
        client.start();
        return client;
    }
}

4. 实现分布式锁工具类

@Component
public class ZookeeperDistributedLock {

    private final CuratorFramework client;

    private static final String LOCK_ROOT_PATH = "/locks";

    public ZookeeperDistributedLock(CuratorFramework client) {
        this.client = client;
    }

    /**
     * 获取互斥锁
     * @param lockPath 锁路径
     * @param timeout 超时时间(毫秒)
     * @return 锁对象
     */
    public InterProcessMutex acquireMutex(String lockPath, long timeout) throws Exception {
        String path = LOCK_ROOT_PATH + "/" + lockPath;
        InterProcessMutex mutex = new InterProcessMutex(client, path);
        
        if (mutex.acquire(timeout, TimeUnit.MILLISECONDS)) {
            return mutex;
        }
        return null;
    }

    /**
     * 释放锁
     * @param mutex 锁对象
     */
    public void releaseMutex(InterProcessMutex mutex) {
        try {
            if (mutex != null && mutex.isAcquiredInThisProcess()) {
                mutex.release();
            }
        } catch (Exception e) {
            throw new RuntimeException("释放锁失败", e);
        }
    }
}

5. 使用分布式锁

在业务代码中使用分布式锁：

@Service
public class OrderService {

    @Autowired
    private ZookeeperDistributedLock distributedLock;

    public void createOrder() {
        InterProcessMutex lock = null;
        try {
            // 获取锁，设置超时时间5秒
            lock = distributedLock.acquireMutex("order-create", 5000);
            if (lock != null) {
                // 获取锁成功，执行业务逻辑
                System.out.println("获取锁成功，开始处理业务");
                // 模拟业务处理
                Thread.sleep(2000);
                System.out.println("业务处理完成");
            } else {
                System.out.println("获取锁失败，可能有其他实例正在处理");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            if (lock != null) {
                distributedLock.releaseMutex(lock);
            }
        }
    }
}

6. 测试分布式锁

可以启动多个Spring Boot实例来测试分布式锁的效果：

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @GetMapping("/create")
    public String createOrder() {
        orderService.createOrder();
        return "订单创建请求已提交";
    }
}

实现原理说明

临时顺序节点：Zookeeper的分布式锁实际上是利用了临时顺序节点的特性

锁获取：

每个客户端在指定的锁路径下创建临时顺序节点
判断自己创建的节点是否是当前最小的节点，如果是则获取锁
如果不是则监听前一个节点的删除事件

锁释放：

任务完成后删除自己创建的节点
下一个节点会收到通知并获取锁

注意事项

连接管理：确保Zookeeper客户端连接的正确管理和异常处理
锁超时：设置合理的锁超时时间，避免死锁
锁释放：务必在finally块中释放锁，防止锁泄漏
重试机制：网络不稳定时需要有合理的重试机制
锁粒度：根据业务需求设计合理的锁粒度

以上实现使用了Curator框架，它封装了Zookeeper的复杂操作，提供了更简单易用的API，特别是它的InterProcessMutex类已经实现了分布式锁的核心逻辑。

到此这篇关于SpringBoot使用Zookeeper实现分布式锁的实现示例的文章就介绍到这了,更多相关SpringBoot Zookeeper分布式锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！