通过zk 创建子节点源码方法（addChild）可以看到，其采用了synchronized 关键字修饰，保证创建子节点的方法是同步方法；在集群的环境下，leader 只有一台，fllower 接收到增、删、改请求后，会将请求转发到leader服务节点上统一执行，结合synchronized 就能保证节点创建不会重复；

/**
 * Method that inserts a child into the children set
 * 
 * @param child
 *            to be inserted
 * @return true if this set did not already contain the specified element
 */
public synchronized boolean addChild(String child) {
    if (children == null) {
        // let's be conservative on the typical number of children
        children = new HashSet<String>(8);
    }
    return children.add(child);
}

Zookeeper 分布式锁实现方式有哪些？

方案一：采用zookeeper 原生实现

存在问题：1. 没有解决锁重入问题

2. 缺少网络连接失败重试处理

3. 没有解决羊群效应问题

方案二：采用Curator 开源框架实现zk 分布式锁

Curator

Curator + spring boot 实现分布式锁

环境： spring boot 2.3.2 release + zookeeper 3.6.0 + jdk1.8

maven 依赖

 <!--zk 锁-->
        <!--curator-->
        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.8.0</version>
        </dependency>

        <!--zookeeper-->
        <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
        </dependency>

配置

curator:
  # 重试次数
  retryCount: 5
  # 重试时间间隔
  elapsedTimeMs: 5000
  # zk 地址
  connectString: 127.0.0.1:2181
  # session 超时时间,客户端断开后，60s 服务端删除临时节点
  sessionTimeoutMs: 60000
  # 连接超时
  connectionTimeoutMs: 5000

实现

package com.springcloud.alibaba.lock;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
* 读取配置类
 * @Author corn
 * @Date 2021/3/9 23:36
 */
@Data
@Component
@ConfigurationProperties(prefix = "curator")
public class CuratorConfig {
    private int retryCount;

    private int elapsedTimeMs;

    private String connectString;

    private int sessionTimeoutMs;

    private int connectionTimeoutMs;
}

package com.springcloud.alibaba.lock;

import lombok.RequiredArgsConstructor;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryOneTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 初始化CuratorFramework
 * @Author corn
 * @Date 2021/3/9 23:33
 */
@Service
@RequiredArgsConstructor(onConstructor = @_(@Autowired))
public class CuratorInit {


    private final CuratorConfig config;


    public CuratorFramework curatorInit(CuratorFramework curatorFramework){
        RetryOneTime retryOneTime = new RetryOneTime(config.getRetryCount());
        curatorFramework = CuratorFrameworkFactory.builder()
                .connectString(config.getConnectString())
                .sessionTimeoutMs(config.getSessionTimeoutMs())
                .connectionTimeoutMs(config.getConnectionTimeoutMs())
                .retryPolicy(retryOneTime)
                .build();
        curatorFramework.start();
        return curatorFramework;
    }
}

/**
     *@描述 测试类
     *@参数 
     *@返回值 
     *@创建人  corn
     *@创建时间  2021/3/13
     */
    @Test
    public void zkLockTest() throws Exception {
        curatorFramework = curatorInit.curatorInit(curatorFramework);
        String path = "/produceApple";
        // 获取锁对象
        InterProcessMutex interProcessMutex = new InterProcessMutex(curatorFramework, path);
        // 获取锁
        interProcessMutex.acquire();
        Thread.sleep(100000);
        // 释放锁
        interProcessMutex.release();
    }