zookeeper实用（2）：实现分布式锁

最新推荐文章于 2022-08-01 14:37:52 发布
最新推荐文章于 2022-08-01 14:37:52 发布
阅读量116 收藏
点赞数
分类专栏： zookeeper 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meishibuyaodarao/article/details/110749055
版权

场景：

分布式锁主要用于在分布式环境中保护跨进程、跨主机、跨网络的共享资源实现互斥访问，以达到保证数据的一致性。

在分布式环境下分布式锁的使用场景，比如秒杀情况，分布式任务，限制访问（同一时间只能发起一次）等。在单机环境中不推荐使用分布式锁，因为分布式锁使用会有一些性能开销的。

分布式锁的实现方式很多，比如DB，redis，zookeeper或者自己实现锁服务。

测试代码：

package com.example.demo.util;

import org.I0Itec.zkclient.ZkClient;

import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public final class DLock
{
    private ZkClient zkClient;
    private String lockName;
    private String thisReadLock;
    private String thisWriteLock;

    /**
     * 分布式锁连接zookeeper 以及 初始化锁主节点
     *
     * @param hostUrl  zookeeper 连接url
     * @param lockName 锁主节点
     */
    public void connect(String hostUrl , String lockName)
    {
        this.lockName = lockName;
        zkClient = new ZkClient(hostUrl);
        if (!zkClient.exists(lockName))
            zkClient.createPersistent(lockName);
    }

    /**
     * 获取读锁
     */
    public void lockRead()
    {
        CountDownLatch readLatch = new CountDownLatch(1);
        // 创建此临时节点， 获取带有顺序号的完整节点
        String thisLockNodeBuilder = lockName + "/" + LockType.READ + "-";
        thisReadLock = zkClient.createEphemeralSequential(thisLockNodeBuilder , "");

        // 找到此读锁前一个写锁。 找到节点的子节点
        List<String> tmp_nodes = zkClient.getChildren(lockName);
        sortNodes(tmp_nodes);
        tmp_nodes.forEach(System.out::println);

        int tmp_index = 0;
        // 倒序循环，直到读锁前面所有的写锁释放，读锁才执行
        for (int i = tmp_nodes.size() - 1; i >= 0; i--)
        {
            if (thisReadLock.equals(lockName + "/" + tmp_nodes.get(i)))
            {
                tmp_index = i;
            } else if (i < tmp_index && tmp_nodes.get(i).split("-")[0].equals(LockType.WRITE.toString()))
            {
                // 找到当前读锁之前的一个写锁
                // 先监听此写锁（监听该写锁是否释放），再阻塞当前读锁
                zkClient.subscribeChildChanges(lockName + "/" + tmp_nodes.get(i) , (parentPath , currentChilds) -> readLatch.countDown());

                try
                {
                    readLatch.await();
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                break;
            }
        }
    }

    /**
     * 释放读锁
     */
    public void unLockRead()
    {
        if (this.thisReadLock != null)
        {
            zkClient.delete(thisReadLock);
            thisReadLock = null;
        }
    }

    /**
     * 获取写锁
     */
    public void lockWrite()
    {
        CountDownLatch writeLatch = new CountDownLatch(1);
        // 创建此临时节点， 获取带有顺序号的完整节点
        String thisLockNodeBuilder = lockName + "/" + LockType.WRITE + "-";
        thisWriteLock = zkClient.createEphemeralSequential(thisLockNodeBuilder , "");

        List<String> tmp_nodes = zkClient.getChildren(lockName);
        sortNodes(tmp_nodes);
        // 倒序循环，直到拿到最前面的写锁，它释放了，后面的写锁才能执行
        for (int i = tmp_nodes.size() - 1; i >= 0; i--)
        {
            if (thisWriteLock.equals(lockName + "/" + tmp_nodes.get(i)))
            {
                // 在锁列表中找到此写锁
                if (i > 0)
                {
                    // 如果此写锁前面还有锁
                    // 监听前面的锁(监听前面的锁是否释放)， 然后阻塞当前写锁获取
                    zkClient.subscribeChildChanges(lockName + "/" + tmp_nodes.get(i - 1) , (parentPath , currentChilds) -> writeLatch.countDown());

                    try
                    {
                        // 阻塞当前写锁获取
                        writeLatch.await();
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    break;
                }
            }
        }
    }

    /**
     * 释放写锁
     */
    public void unLockWrite()
    {
        if (thisWriteLock != null)
        {
            zkClient.delete(thisWriteLock);
            thisWriteLock = null;
        }
    }

    /**
     * 重新对节点进行排序，按照顺序号排序
     *
     * @param nodes 临时节点
     */
    private void sortNodes(List<String> nodes)
    {
        nodes.sort(Comparator.comparing(o -> o.split("-")[1]));
    }

    /**
     * 锁类型枚举
     */
    private enum LockType
    {
        READ,
        WRITE;
    }
}

模拟多客户端并发请求：

import com.example.demo.util.DLock;
import org.springframework.beans.factory.annotation.Value;

public class TestDLock {

    private static String hostUrl = "127.0.0.1:2181";

    public static void main(String[] args) {
        dLockClient1();
        dLockClient2();
        dLockClient3();
        dLockClient4();
    }

    public static void dLockClient1(){
        // 客户端1
        DLock lock=new DLock();
        lock.connect(hostUrl, "/lock");
        lock.lockRead();
        System.out.println("I am testNode 1");
        try
        {
            System.out.println("I am TestNode 1");
            System.out.println("睡眠10s 之后释放分布式读锁, 开始倒计时");
            for (int i = 0; i < 10; i++)
            {
                System.out.println(10-i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        lock.unLockRead();
    }

    public static void dLockClient2(){
        // 客户端2
        DLock lock=new DLock();
        lock.connect(hostUrl, "/lock");
        lock.lockRead();
        System.out.println("I am TestNode 2");
        lock.unLockRead();
    }

    public static void dLockClient3(){
        // 客户端3
        DLock lock=new DLock();
        lock.connect(hostUrl, "/lock");
        lock.lockWrite();
        System.out.println("I am testNode 3");
        System.out.println("睡眠10s 之后释放分布式写锁, 开始倒计时");
        for (int i = 0; i < 10; i++)
        {
            System.out.println(10-i);
            try
            {
                Thread.sleep(1000);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        lock.unLockWrite();
    }

    public static void dLockClient4(){
        // 客户端4
        DLock lock=new DLock();
        lock.connect(hostUrl, "/lock");
        lock.lockRead();
        System.out.println("I am TestNode 4");
        lock.unLockRead();
    }
}

运行结果：

READ-0000000000
I am testNode 1
I am TestNode 1
睡眠10s 之后释放分布式读锁, 开始倒计时
10
9
8
7
6
5
4
3
2
1
17:44:29.643 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x100026588980000 after 12ms
17:44:29.804 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980000, packet:: clientPath:null serverPath:null finished:false header:: 5,2  replyHeader:: 5,30064771079,0  request:: '/lock/READ-0000000000,-1  response:: null
17:44:29.805 [main] DEBUG org.I0Itec.zkclient.ZkConnection - Creating new ZookKeeper instance to connect to 127.0.0.1:2181.
17:44:29.805 [main] INFO org.apache.zookeeper.ZooKeeper - Initiating client connection, connectString=127.0.0.1:2181 sessionTimeout=30000 watcher=org.I0Itec.zkclient.ZkClient@1e643faf
17:44:29.805 [ZkClient-EventThread-15-127.0.0.1:2181] INFO org.I0Itec.zkclient.ZkEventThread - Starting ZkClient event thread.
17:44:29.809 [main] DEBUG org.I0Itec.zkclient.ZkClient - Awaiting connection to Zookeeper server
17:44:29.809 [main] INFO org.I0Itec.zkclient.ZkClient - Waiting for keeper state SyncConnected
17:44:29.810 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Opening socket connection to server 127.0.0.1/127.0.0.1:2181. Will not attempt to authenticate using SASL (unknown error)
17:44:29.812 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Socket connection established to 127.0.0.1/127.0.0.1:2181, initiating session
17:44:29.812 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Session establishment request sent on 127.0.0.1/127.0.0.1:2181
17:44:29.827 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Session establishment complete on server 127.0.0.1/127.0.0.1:2181, sessionid = 0x100026588980001, negotiated timeout = 30000
17:44:29.827 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Received event: WatchedEvent state:SyncConnected type:None path:null
17:44:29.827 [main-EventThread] INFO org.I0Itec.zkclient.ZkClient - zookeeper state changed (SyncConnected)
17:44:29.828 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Leaving process event
17:44:29.828 [main] DEBUG org.I0Itec.zkclient.ZkClient - State is SyncConnected
17:44:29.838 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980001, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,30064771080,0  request:: '/lock,F  response:: s{30064771077,30064771077,1607247859574,1607247859574,0,2,0,0,0,0,30064771079} 
17:44:29.847 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980001, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,30064771081,0  request:: '/lock/READ-,#ffffffacffffffed057400,v{s{31,s{'world,'anyone}}},3  response:: '/lock/READ-0000000001 
17:44:29.851 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980001, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,30064771081,0  request:: '/lock,F  response:: v{'READ-0000000001} 
READ-0000000001
I am TestNode 2
17:44:29.859 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980001, packet:: clientPath:null serverPath:null finished:false header:: 4,2  replyHeader:: 4,30064771082,0  request:: '/lock/READ-0000000001,-1  response:: null
17:44:29.860 [main] DEBUG org.I0Itec.zkclient.ZkConnection - Creating new ZookKeeper instance to connect to 127.0.0.1:2181.
17:44:29.860 [main] INFO org.apache.zookeeper.ZooKeeper - Initiating client connection, connectString=127.0.0.1:2181 sessionTimeout=30000 watcher=org.I0Itec.zkclient.ZkClient@6e8dacdf
17:44:29.860 [ZkClient-EventThread-18-127.0.0.1:2181] INFO org.I0Itec.zkclient.ZkEventThread - Starting ZkClient event thread.
17:44:29.862 [main] DEBUG org.I0Itec.zkclient.ZkClient - Awaiting connection to Zookeeper server
17:44:29.862 [main] INFO org.I0Itec.zkclient.ZkClient - Waiting for keeper state SyncConnected
17:44:29.862 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Opening socket connection to server 127.0.0.1/127.0.0.1:2181. Will not attempt to authenticate using SASL (unknown error)
17:44:29.863 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Socket connection established to 127.0.0.1/127.0.0.1:2181, initiating session
17:44:29.863 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Session establishment request sent on 127.0.0.1/127.0.0.1:2181
17:44:29.870 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Session establishment complete on server 127.0.0.1/127.0.0.1:2181, sessionid = 0x100026588980002, negotiated timeout = 30000
17:44:29.870 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Received event: WatchedEvent state:SyncConnected type:None path:null
17:44:29.870 [main-EventThread] INFO org.I0Itec.zkclient.ZkClient - zookeeper state changed (SyncConnected)
17:44:29.871 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Leaving process event
17:44:29.871 [main] DEBUG org.I0Itec.zkclient.ZkClient - State is SyncConnected
17:44:29.875 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980002, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,30064771083,0  request:: '/lock,F  response:: s{30064771077,30064771077,1607247859574,1607247859574,0,4,0,0,0,0,30064771082} 
17:44:29.882 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980002, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,30064771084,0  request:: '/lock/WRITE-,#ffffffacffffffed057400,v{s{31,s{'world,'anyone}}},3  response:: '/lock/WRITE-0000000002 
17:44:29.885 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980002, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,30064771084,0  request:: '/lock,F  response:: v{'WRITE-0000000002} 
I am testNode 3
睡眠10s 之后释放分布式写锁, 开始倒计时
10
9
8
7
6
5
4
3
2
1
17:44:39.790 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x100026588980000 after 5ms
17:44:39.864 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x100026588980001 after 3ms
17:44:39.898 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x100026588980002 after 5ms
17:44:39.992 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980002, packet:: clientPath:null serverPath:null finished:false header:: 4,2  replyHeader:: 4,30064771085,0  request:: '/lock/WRITE-0000000002,-1  response:: null
17:44:39.993 [main] DEBUG org.I0Itec.zkclient.ZkConnection - Creating new ZookKeeper instance to connect to 127.0.0.1:2181.
17:44:39.994 [main] INFO org.apache.zookeeper.ZooKeeper - Initiating client connection, connectString=127.0.0.1:2181 sessionTimeout=30000 watcher=org.I0Itec.zkclient.ZkClient@7a79be86
17:44:39.994 [ZkClient-EventThread-21-127.0.0.1:2181] INFO org.I0Itec.zkclient.ZkEventThread - Starting ZkClient event thread.
17:44:40.002 [main] DEBUG org.I0Itec.zkclient.ZkClient - Awaiting connection to Zookeeper server
17:44:40.002 [main] INFO org.I0Itec.zkclient.ZkClient - Waiting for keeper state SyncConnected
17:44:40.003 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Opening socket connection to server 127.0.0.1/127.0.0.1:2181. Will not attempt to authenticate using SASL (unknown error)
17:44:40.005 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Socket connection established to 127.0.0.1/127.0.0.1:2181, initiating session
17:44:40.005 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Session establishment request sent on 127.0.0.1/127.0.0.1:2181
17:44:40.021 [main-SendThread(127.0.0.1:2181)] INFO org.apache.zookeeper.ClientCnxn - Session establishment complete on server 127.0.0.1/127.0.0.1:2181, sessionid = 0x100026588980003, negotiated timeout = 30000
17:44:40.021 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Received event: WatchedEvent state:SyncConnected type:None path:null
17:44:40.021 [main-EventThread] INFO org.I0Itec.zkclient.ZkClient - zookeeper state changed (SyncConnected)
17:44:40.021 [main-EventThread] DEBUG org.I0Itec.zkclient.ZkClient - Leaving process event
17:44:40.022 [main] DEBUG org.I0Itec.zkclient.ZkClient - State is SyncConnected
17:44:40.032 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980003, packet:: clientPath:null serverPath:null finished:false header:: 1,3  replyHeader:: 1,30064771086,0  request:: '/lock,F  response:: s{30064771077,30064771077,1607247859574,1607247859574,0,6,0,0,0,0,30064771085} 
17:44:40.042 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980003, packet:: clientPath:null serverPath:null finished:false header:: 2,1  replyHeader:: 2,30064771087,0  request:: '/lock/READ-,#ffffffacffffffed057400,v{s{31,s{'world,'anyone}}},3  response:: '/lock/READ-0000000003 
17:44:40.046 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980003, packet:: clientPath:null serverPath:null finished:false header:: 3,8  replyHeader:: 3,30064771087,0  request:: '/lock,F  response:: v{'READ-0000000003} 
READ-0000000003
I am TestNode 4
17:44:40.052 [main-SendThread(127.0.0.1:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Reading reply sessionid:0x100026588980003, packet:: clientPath:null serverPath:null finished:false header:: 4,2  replyHeader:: 4,30064771088,0  request:: '/lock/READ-0000000003,-1  response:: null

Process finished with exit code 0

 

代码狩猎者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现分布式锁的解决方案
赵广陆
01-04 1197
目录1. 分布式锁1.1 什么是分布式锁1.2 为什么要使用分布式锁1.3 分布式锁应具有的特性2 分布式锁实现方案2.1 数据库实现分布式锁2.2 ZooKeeper实现分布式锁2.3 Redis实现分布式锁2.3.1 版本一2.3.2 版本二2.3.3 版本三3. Redisson3.1 Redisson介绍3.2 Redisson分布式锁使用方式3.3 Lua脚本3.3.1 Lua简介3.3.2 Redis中使用Lua的好处3.3.3 如何在Redis中使用Lua 1. 分布式锁 1.1 什么是分布
zookeeper分布式锁
三季人的博客
11-28 1832
分布式锁 准备工作 导入依赖 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>RELEASE</version> </dependency> <dependency> <groupId>org.apache.logging.log4j&l
zookeeper 实现分布式锁
srjkgoreihgw的博客
06-16 114
1.zookeeper简介 zookeeper是一个分布式协调服务 应用场景：1.维护服务配置信息 2.分布式锁 3.集群管理 4.生成分布式唯一ID 2.zookeeper实现分布式锁的原理 大概步骤：当客户端需要获取锁，那么创建节点；释放锁，那么删除节点。 具体步骤： 客户端获取锁时，在lock节点下创建 临时顺序 节点。 然后获取lock节点下的所有子节点，客户端获取到所有的子节点之后，如果发现自己创建节点的序号最小，那么就认为客户端获取到了锁，使用完锁之后将该节点删除。 如果发现当前节点
[RMI TCP Connection(10.0.20.175:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for
伏虎游侠的博客
08-23 8233
https://www.jianshu.com/p/fcb6eb0a86d6 [RMI TCP Connection(10.0.20.175:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x15aeeb4d0c80bdb after 1ms 一日，工程一直再报 [RMI T...
Zookeeper连接异常 Got ping response for sessionid 2021-06-30
weixin_45803109的博客
09-24 7739
日志中一直打印 Got ping response for sessionid 表示连接zookeeper 超时以下原因: 1.zookeeper 未开启 请确认是否开启 2.配置文件端口配置有误 可去cmd内ping 确认可以ping到 （需要联网 且以管理员身份运行才有效） 3.发现zookeeper并无问题后 再去仔细检查项目工程: (1) 是否远程调用的service 出现重名 （本人没有遇到过 报这个错误也非此原因 网上有人说可能是这个的原因 ...
java使用zookeeper实现的分布式锁示例
09-04
接着，实现分布式锁的核心逻辑在于`lock()`和`unlock()`方法。当调用`lock()`时，`DistributedLock`会在`/locks`的子目录下创建一个临时顺序节点（通过`CreateMode.EPHEMERAL_SEQUENTIAL`模式创建）。临时节点会在...
基于zookeeper的分布式锁简单实现
12-15
这时，Zookeeper，一个高可用的分布式协调服务，常被用来实现分布式锁。 Zookeeper由Apache基金会开发，它提供了一种可靠的分布式一致性服务，包括命名服务、配置管理、集群同步、领导者选举等功能。Zookeeper基于...
分布式锁用 Redis 还是 Zookeeper？
Linuxhus的博客
07-14 782
在讨论这个问题之前，我们先来看一个业务场景：系统A是一个电商系统，目前是一台机器部署，系统中有一个用户下订单的接口，但是用户下订单之前一定要去检查一下库存，确保库存足够了才会给用户下单。由于系统有一定的并发，所以会预先将商品的库存保存在redis中，用户下单的时候会更新redis的库存。此时系统架构如下：但是这样一来会产生一个问题：假如某个时刻，redis里面的某个商品库存为1，此时两个请求同时到来，其中一个请求执行到上图的第3步，更新数据库的库存为0，但是第4步还没有执行。而另外一个请求执行到了第2步，发
Zookeeper学习：Zookeeper应用场景之分布式锁
小松de博客
10-28 394
1. 分布式锁的介绍 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要通过一些互斥手段来防止彼此之间的干扰，以保证一致性，在这种情况下，就需要使用分布式锁了。 在平时的实际项目开发中，我们往往很少会去在意分布式锁，而是依赖于关系型数据库固有的排他性来实现不同进程之间的互斥。这确实是一种非常简便且被广泛使用的分布式锁实现方式。然而有一个不争的事实是，目前绝大多数大型分布式系统的性能瓶颈都集中在数据库操作上。
org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x160fd6f04410017 after 0ms
weixin_34198762的博客
03-28 1万+
dubbo报错： org.apache.zookeeper.ClientCnxn - Got ping response for sessionid: 0x160fd6f04410017 after 0ms 原因：dubbo注册的服务有重复的service名称或实现类； 转载于:https://www.cnblogs.com/YuyuanNo1/p/8662562.html...
idea 开启debug模式,zookeeper超时
lvyinxiazheyang的博客
08-01 2176
当正常运行时,zookeeper不会超时;当开始debug模式时，总是超时，一开始认为是虚拟机的内存问题，导致zookeeper超时，但两种模式均用的同一个tomcat的配置文件，直接执行,zookeep不报错，所以不应当是tomcat内存设置的问题 最后发现是自己以前的debug打的断点太多，导致运行变慢，从而zookeeper超时。不能在方法上打断点，这样会特别慢。解决办法： 找到自己曾经打
如何关闭 org.apache.zookeeper.clientcnxn 的(控制台大量输出)debug 日志
comefromcq的专栏
12-06 7680
如何关闭 org.apache.zookeeper.clientcnxn 的(控制台大量输出)debug 日志
进行一个for循环时候，单个对象获取的时候出现了奇怪的现象
chuqiong9757的博客
07-09 258
2019-07-09 16:19:30.126 [restartedMain-SendThread(172.16.3.139:2181)] DEBUG org.apache.zookeeper.ClientCnxn - Got ping response for session...
ZooKeeper 使用中的问题：Len error
热门推荐
wenniuwuren
10-28 1万+
一. 问题现场：     一天夜里，一台服务器的 zk client 与 server 断开，一般情况下程序写好了自动重连会自动重连成功，但是这一次，怎么重连都连不上了。     client 端日志如下：就是不停地重连，但是连不上，看日志像是服务端挂了，但是其他 client 确好好地，说明服务端没挂 2017-10-07 23:59:44.466 [DEBUG] [org.apa
Zookeeper watcher事件机制源码剖析
captian_900331的博客
06-29 739
一、zk的watcher机制的过程： 1、客户端注册watcher 2、服务端注册watcher 3、服务端触发watcher事件 3、客户端回调watcher 二、客户端注册watcher有三种方式，可以调用getData，exists、getChildred实现 public Logger logger = LoggerFactory.getLogger(WatcherDemo.class); //zookeeper连接地址 private static String ZOOKEEP
zookeeper客户端ZooKeeperMain源码分析
weixin_45453628的博客
08-01 1022
zookeeper客户端ZooKeeperMain源码分析
ZooKeeper实用解析：主从模式与分布式协调
ZooKeeper的API允许客户端轻松实现分布式锁，这是主从模式中管理权变更的关键。例如，各个客户端实例尝试创建一个临时znode来竞争成为主节点，第一个成功创建的客户端即成为主节点。 Curator是ZooKeeper的一个高级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值