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

<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>

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

@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;
    }
}

@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);
        }
    }
}

@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);
            }
        }
    }
}

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

    @Autowired
    private OrderService orderService;

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