JavaDevOps技术栈

zookeeper实现分布式锁

本文根据zk的临时有序节点特性，实现分布式场景下的读写锁，所谓读写锁（读写有序），就是读写互斥，写写互斥，可以连续读，提高读的并发。

大概原理如下：：

1、创建跟节点，也就是锁的主题

2、获取锁时，现在根节点下创建临时节点，注意（锁有读锁和写锁区分，读READ 写WRITE）

3、创建节点成功，则进行获取锁资源判断

4、获得所有的节点，按照需要升序排序

5、如果第一个节点就是当前节点，则获取锁

6、如果当前节点是写节点，则直接监听此节点的上一个节点即可

7、如果是读节点，则判断比自己小的节点是否存在写节点，不存在获取锁

8、存在写节点，则监听最近的写节点，

代码如下：

package com.ribbon.demo.lock.zookeeper;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

import java.util.concurrent.CountDownLatch;

@Configuration
public class ZookeeperConfig {
    private static final Logger logger = LoggerFactory.getLogger(ZookeeperConfig.class);

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

    @Value("${zookeeper.timeout}")
    private int timeout;
    /**
     * zookeeper client
     * @return
     */
    @Bean(name = "zkClient")
    public ZooKeeper zkClient() {
        ZooKeeper zooKeeper = null;
        try {
            final CountDownLatch countDownLatch = new CountDownLatch(1);
            //连接成功后，会回调watcher监听，此连接操作是异步的，执行完new语句后，直接调用后续代码
            zooKeeper = new ZooKeeper(connect, timeout, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (Event.KeeperState.SyncConnected == event.getState()) {
                        //如果收到了服务端的响应事件,连接成功
                        countDownLatch.countDown();
                    }
                }
            });
            countDownLatch.await();
            logger.info("【初始化ZooKeeper连接状态....】={}", zooKeeper.getState());
        } catch (Exception e) {
            logger.error("初始化ZooKeeper连接异常....】={}", e);
        }
        return zooKeeper;
    }

}

package com.ribbon.demo.lock.zookeeper;


import lombok.Data;

@Data
public class LockNode {
    private String lockId;
    private String path;
    private boolean active;
    public LockNode(String lockId, String path) {
        this.lockId = lockId;
        this.path = path;
    }


}

package com.ribbon.demo.lock.zookeeper;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * TODO
 *
 * @author yyl
 * @date 2022/8/2 22:25
 * @desc
 */
@Component
@Slf4j
public class ZookeeperLock implements InitializingBean {

    @Autowired
    private ZooKeeper zooKeeperClient;

    private  static final String  rootPath = "/test-lock";
    private  static final String WRITE = "WRITE";
    private  static final String READ = "READ";

    @Override
    public void afterPropertiesSet() throws Exception {
        Stat rootPathExists = zooKeeperClient.exists(rootPath, false);
        if (rootPathExists == null) {
            //不存在节点 则创建根节点
            zooKeeperClient.create(rootPath,null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }


    /**
     * 获取锁
     */
    @SneakyThrows
    public LockNode lock(String lockId, long timeOut){
        // 创建临时节点
        LockNode lockNode = createLockNode(lockId);
        tryActiveLock(lockNode);
        //没有获得锁，进入超时等待
        if (!lockNode.isActive()) {
            synchronized (lockNode) {
                log.info("当前线程等待：{}",lockNode.getPath());
                lockNode.wait(timeOut);
               log.info("当前线程唤醒：{}",lockNode.getPath());
            }
        }

        if (!lockNode.isActive()) {
            throw new RuntimeException(" lock  timeout");
        }
//      log.info("当前获得锁{}",lockNode);
        return lockNode;
    }


    /**
     * 释放锁
     */
    @SneakyThrows
    public void unlock(LockNode lockNode) {
        if (lockNode.isActive()) {
            //version参数指定要更新的数据的版本, 如果version和真实的版本不同, 更新操作将失败. 指定version为-1则忽略版本检查
            zooKeeperClient.delete(lockNode.getPath(),-1);
//            log.info("释放锁：{}",lockNode.getPath());
        }
    }

    /**
     * 创建临时有序节点
     * @param lockId
     * @return
     */
    @SneakyThrows
    private LockNode createLockNode(String lockId) {
        String nodePath = zooKeeperClient.create(rootPath + "/" + lockId, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        return new LockNode(lockId, nodePath);
    }



    /**
     *尝试激活锁
     */
    @SneakyThrows
    public void tryActiveLock(LockNode lockNode){
//        log.info("当前节点：{}",lockNode);
        //获取所有子节点数据
        List childrens= zooKeeperClient.getChildren(rootPath, false);
        //根据节点顺序进行升序排序
        List sortRealPathChildrens = childrens.stream().sorted(Comparator.comparing(x->x.replace(WRITE,"").replace(READ,""))).map(p -> rootPath + "/" + p).collect(Collectors.toList());
//        log.info("当前根节点下子节点排序后：{}",sortRealPathChildrens);
        //最小的节点是否是自己
        if(sortRealPathChildrens.get(0).equals(lockNode.getPath())){
            lockNode.setActive(true);
            return;
        }
        //当前节点是读还是写
        if(lockNode.getPath().contains(WRITE)){
            //当前是写节点，监控最后一个节点即可
            String watchNodePath = sortRealPathChildrens.get(sortRealPathChildrens.indexOf(lockNode.getPath()) - 1);
            this.watchNode(watchNodePath,lockNode);
            return;
        }
        //非写节点，找里自己最近的一个写节点监听
        List minWriteNodepath = sortRealPathChildrens.subList(0, sortRealPathChildrens.indexOf(lockNode.getPath())).stream().filter(x -> x.contains(WRITE)).collect(Collectors.toList());
//        List writeNodes = sortRealPathChildrens.stream().filter(x -> x.contains(WRITE)).collect(Collectors.toList());
        //如果不存在写节点,则可以获取锁
        if(CollectionUtils.isEmpty(minWriteNodepath)){
//            log.info("当前读操作，前面没有写节点",lockNode.getPath());
            lockNode.setActive(true);
            return;
        }
        //之前的节点存在写节点 需要监听比自己节点大点的写节点
//        log.info("当前读操作，监控的写节点",minWriteNodepath);
        String watchNodePath = minWriteNodepath.get(minWriteNodepath.size() - 1);
        this.watchNode(watchNodePath,lockNode);
    }


    @SneakyThrows
    private void watchNode(String watchNodePath,LockNode lockNode) {
//        log.info("当前节点：{}，需要监听节点：{}",lockNode.getPath(),watchNodePath);
        //AddWatchMode.PERSISTENT： 表示只关心当前节点的删除、数据变更，创建，一级子节点的创建、删除；无法感知子节点的子节点创建、删除，无法感知子节点的数据变更
        //AddWatchMode.PERSISTENT_RECURSIVE: 相当于递归监听，改节点及其子节点的所有变更都监听
        //当节点出现创建/删除 或者 新增数据时，触发watcher回调
        Stat exists = zooKeeperClient.exists(watchNodePath, new Watcher() {
            @Override
            public void process(WatchedEvent watchedEvent) {
                Event.EventType type = watchedEvent.getType();
//                log.info("节点变更：：{}", type);
                tryActiveLock(lockNode);
                synchronized (lockNode) {
                    if (lockNode.isActive()) {
                        log.info("唤醒当前线程：{}", lockNode.getPath());
                        lockNode.notify();
                    }
                }

            }
        });
//        log.info("监听结果：{}", exists);
        //防止监听的时候，正好节点删除，那么则重新获取锁
        if(exists == null){
            tryActiveLock(lockNode);
        }
        /* zooKeeperClient.addWatch(watchNodePath,watchedEvent -> {
        }, AddWatchMode.PERSISTENT);*/

    }

}

测试结果：

2022-08-06 11:58:34.424  INFO 11236 --- [      Thread-18] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000367, active=true)
2022-08-06 11:58:34.429  INFO 11236 --- [      Thread-14] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000368, active=true)
2022-08-06 11:58:34.551  INFO 11236 --- [      Thread-13] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000366, active=true)
2022-08-06 11:58:34.554  INFO 11236 --- [      Thread-17] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000369, active=true)
============
2022-08-06 11:58:34.772  INFO 11236 --- [      Thread-15] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000370, active=true)
2022-08-06 11:58:39.440  INFO 11236 --- [      Thread-18] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000367, active=true)
2022-08-06 11:58:39.442  INFO 11236 --- [      Thread-14] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000368, active=true)
2022-08-06 11:58:39.562  INFO 11236 --- [      Thread-13] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000366, active=true)
2022-08-06 11:58:39.565  INFO 11236 --- [      Thread-17] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000369, active=true)
2022-08-06 11:58:39.785  INFO 11236 --- [      Thread-15] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000370, active=true)
2022-08-06 11:58:39.798  INFO 11236 --- [      Thread-16] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000371, active=true)
2022-08-06 11:58:44.811  INFO 11236 --- [      Thread-16] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000371, active=true)
2022-08-06 11:58:44.826  INFO 11236 --- [       Thread-9] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000372, active=true)
2022-08-06 11:58:49.846  INFO 11236 --- [       Thread-9] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000372, active=true)
2022-08-06 11:58:49.863  INFO 11236 --- [      Thread-77] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000373, active=true)
2022-08-06 11:58:54.874  INFO 11236 --- [      Thread-77] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000373, active=true)
2022-08-06 11:58:54.890  INFO 11236 --- [       Thread-5] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000374, active=true)
2022-08-06 11:58:59.904  INFO 11236 --- [       Thread-5] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000374, active=true)
2022-08-06 11:58:59.916  INFO 11236 --- [       Thread-7] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000375, active=true)
2022-08-06 11:59:04.986  INFO 11236 --- [       Thread-7] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000375, active=true)
2022-08-06 11:59:05.013  INFO 11236 --- [      Thread-11] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000376, active=true)
2022-08-06 11:59:10.025  INFO 11236 --- [      Thread-11] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000376, active=true)
2022-08-06 11:59:10.037  INFO 11236 --- [       Thread-3] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000377, active=true)
2022-08-06 11:59:15.051  INFO 11236 --- [       Thread-3] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000377, active=true)
2022-08-06 11:59:15.063  INFO 11236 --- [      Thread-73] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000378, active=true)
2022-08-06 11:59:20.090  INFO 11236 --- [      Thread-73] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000378, active=true)
2022-08-06 11:59:20.108  INFO 11236 --- [      Thread-21] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000379, active=true)
2022-08-06 11:59:25.237  INFO 11236 --- [      Thread-21] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000379, active=true)
2022-08-06 11:59:25.239  INFO 11236 --- [      Thread-69] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000380, active=true)
2022-08-06 11:59:30.254  INFO 11236 --- [      Thread-69] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000380, active=true)
2022-08-06 11:59:30.264  INFO 11236 --- [      Thread-78] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000381, active=true)
2022-08-06 11:59:35.275  INFO 11236 --- [      Thread-78] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000381, active=true)
2022-08-06 11:59:35.285  INFO 11236 --- [      Thread-19] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000382, active=true)
2022-08-06 11:59:40.298  INFO 11236 --- [      Thread-19] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000382, active=true)
2022-08-06 11:59:40.310  INFO 11236 --- [      Thread-74] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000383, active=true)
2022-08-06 11:59:45.324  INFO 11236 --- [      Thread-74] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000383, active=true)
2022-08-06 11:59:45.333  INFO 11236 --- [      Thread-70] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000384, active=true)
2022-08-06 11:59:50.346  INFO 11236 --- [      Thread-70] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000384, active=true)
2022-08-06 11:59:50.357  INFO 11236 --- [      Thread-26] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000385, active=true)
2022-08-06 11:59:55.367  INFO 11236 --- [      Thread-26] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000385, active=true)
2022-08-06 11:59:55.383  INFO 11236 --- [      Thread-24] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000386, active=true)
2022-08-06 12:00:00.393  INFO 11236 --- [      Thread-24] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000386, active=true)
2022-08-06 12:00:00.412  INFO 11236 --- [      Thread-44] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000388, active=true)
2022-08-06 12:00:00.425  INFO 11236 --- [      Thread-32] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000387, active=true)
2022-08-06 12:00:05.432  INFO 11236 --- [      Thread-44] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000388, active=true)
2022-08-06 12:00:05.438  INFO 11236 --- [      Thread-32] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000387, active=true)
2022-08-06 12:00:05.440  INFO 11236 --- [      Thread-36] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000389, active=true)
2022-08-06 12:00:10.457  INFO 11236 --- [      Thread-36] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000389, active=true)
2022-08-06 12:00:10.466  INFO 11236 --- [      Thread-45] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000390, active=true)
2022-08-06 12:00:15.477  INFO 11236 --- [      Thread-45] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000390, active=true)
2022-08-06 12:00:15.486  INFO 11236 --- [      Thread-79] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000391, active=true)
2022-08-06 12:00:20.500  INFO 11236 --- [      Thread-79] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000391, active=true)
2022-08-06 12:00:20.511  INFO 11236 --- [      Thread-66] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000392, active=true)
2022-08-06 12:00:25.526  INFO 11236 --- [      Thread-66] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000392, active=true)
2022-08-06 12:00:25.534  INFO 11236 --- [      Thread-31] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000393, active=true)
2022-08-06 12:00:25.551  INFO 11236 --- [      Thread-27] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000394, active=true)
2022-08-06 12:00:25.561  INFO 11236 --- [      Thread-35] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000395, active=true)
2022-08-06 12:00:30.542  INFO 11236 --- [      Thread-31] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000393, active=true)
2022-08-06 12:00:30.565  INFO 11236 --- [      Thread-27] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000394, active=true)
2022-08-06 12:00:30.574  INFO 11236 --- [      Thread-35] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000395, active=true)
2022-08-06 12:00:30.585  INFO 11236 --- [      Thread-62] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000396, active=true)
2022-08-06 12:00:35.597  INFO 11236 --- [      Thread-62] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000396, active=true)
2022-08-06 12:00:35.608  INFO 11236 --- [      Thread-58] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000397, active=true)
2022-08-06 12:00:40.620  INFO 11236 --- [      Thread-58] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000397, active=true)
2022-08-06 12:00:40.631  INFO 11236 --- [      Thread-54] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000398, active=true)
2022-08-06 12:00:45.643  INFO 11236 --- [      Thread-54] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000398, active=true)
2022-08-06 12:00:45.651  INFO 11236 --- [      Thread-50] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000399, active=true)
2022-08-06 12:00:45.662  INFO 11236 --- [      Thread-46] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000400, active=true)
2022-08-06 12:00:50.791  INFO 11236 --- [      Thread-50] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000399, active=true)
2022-08-06 12:00:50.792  INFO 11236 --- [      Thread-46] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000400, active=true)
2022-08-06 12:00:50.833  INFO 11236 --- [      Thread-42] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000401, active=true)
2022-08-06 12:00:55.864  INFO 11236 --- [      Thread-42] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000401, active=true)
2022-08-06 12:00:55.922  INFO 11236 --- [      Thread-38] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000402, active=true)
2022-08-06 12:01:00.936  INFO 11236 --- [      Thread-38] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000402, active=true)
2022-08-06 12:01:00.945  INFO 11236 --- [      Thread-34] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000403, active=true)
2022-08-06 12:01:06.016  INFO 11236 --- [      Thread-34] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000403, active=true)
2022-08-06 12:01:06.032  INFO 11236 --- [      Thread-30] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000404, active=true)
2022-08-06 12:01:11.047  INFO 11236 --- [      Thread-30] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000404, active=true)
2022-08-06 12:01:11.060  INFO 11236 --- [      Thread-22] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000405, active=true)
2022-08-06 12:01:16.073  INFO 11236 --- [      Thread-22] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000405, active=true)
2022-08-06 12:01:16.084  INFO 11236 --- [      Thread-49] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000406, active=true)
2022-08-06 12:01:21.100  INFO 11236 --- [      Thread-49] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000406, active=true)
2022-08-06 12:01:21.113  INFO 11236 --- [      Thread-53] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000409, active=true)
2022-08-06 12:01:21.121  INFO 11236 --- [      Thread-59] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000412, active=true)
2022-08-06 12:01:21.130  INFO 11236 --- [      Thread-47] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000411, active=true)
2022-08-06 12:01:21.138  INFO 11236 --- [      Thread-51] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000410, active=true)
2022-08-06 12:01:21.148  INFO 11236 --- [      Thread-55] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000408, active=true)
2022-08-06 12:01:21.179  INFO 11236 --- [      Thread-65] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000407, active=true)
2022-08-06 12:01:26.125  INFO 11236 --- [      Thread-53] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000409, active=true)
2022-08-06 12:01:26.135  INFO 11236 --- [      Thread-59] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000412, active=true)
2022-08-06 12:01:26.142  INFO 11236 --- [      Thread-47] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000411, active=true)
2022-08-06 12:01:26.147  INFO 11236 --- [      Thread-51] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000410, active=true)
2022-08-06 12:01:26.156  INFO 11236 --- [      Thread-55] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000408, active=true)
2022-08-06 12:01:26.191  INFO 11236 --- [      Thread-65] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000407, active=true)
2022-08-06 12:01:26.201  INFO 11236 --- [      Thread-57] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000413, active=true)
2022-08-06 12:01:31.212  INFO 11236 --- [      Thread-57] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000413, active=true)
2022-08-06 12:01:31.220  INFO 11236 --- [      Thread-43] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000414, active=true)
2022-08-06 12:01:36.234  INFO 11236 --- [      Thread-43] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000414, active=true)
2022-08-06 12:01:36.243  INFO 11236 --- [      Thread-63] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000415, active=true)
2022-08-06 12:01:41.252  INFO 11236 --- [      Thread-63] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000415, active=true)
2022-08-06 12:01:41.260  INFO 11236 --- [      Thread-61] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000416, active=true)
2022-08-06 12:01:46.272  INFO 11236 --- [      Thread-61] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000416, active=true)
2022-08-06 12:01:46.300  INFO 11236 --- [      Thread-39] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000417, active=true)
2022-08-06 12:01:51.311  INFO 11236 --- [      Thread-39] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000417, active=true)
2022-08-06 12:01:51.319  INFO 11236 --- [      Thread-67] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000418, active=true)
2022-08-06 12:01:56.332  INFO 11236 --- [      Thread-67] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000418, active=true)
2022-08-06 12:01:56.341  INFO 11236 --- [      Thread-23] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000419, active=true)
2022-08-06 12:02:01.350  INFO 11236 --- [      Thread-23] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000419, active=true)
2022-08-06 12:02:01.358  INFO 11236 --- [      Thread-41] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000420, active=true)
2022-08-06 12:02:06.376  INFO 11236 --- [      Thread-41] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000420, active=true)
2022-08-06 12:02:06.383  INFO 11236 --- [      Thread-71] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000421, active=true)
2022-08-06 12:02:06.391  INFO 11236 --- [      Thread-75] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000422, active=true)
2022-08-06 12:02:11.391  INFO 11236 --- [      Thread-71] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000421, active=true)
2022-08-06 12:02:11.400  INFO 11236 --- [      Thread-75] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000422, active=true)
2022-08-06 12:02:11.408  INFO 11236 --- [      Thread-29] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000423, active=true)
2022-08-06 12:02:16.421  INFO 11236 --- [      Thread-29] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000423, active=true)
2022-08-06 12:02:16.430  INFO 11236 --- [      Thread-37] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000424, active=true)
2022-08-06 12:02:21.439  INFO 11236 --- [      Thread-37] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000424, active=true)
2022-08-06 12:02:21.446  INFO 11236 --- [      Thread-25] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000425, active=true)
2022-08-06 12:02:26.457  INFO 11236 --- [      Thread-25] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000425, active=true)
2022-08-06 12:02:26.465  INFO 11236 --- [      Thread-33] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000426, active=true)
2022-08-06 12:02:31.474  INFO 11236 --- [      Thread-33] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000426, active=true)
2022-08-06 12:02:31.482  INFO 11236 --- [       Thread-8] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000427, active=true)
2022-08-06 12:02:36.491  INFO 11236 --- [       Thread-8] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000427, active=true)
2022-08-06 12:02:36.499  INFO 11236 --- [      Thread-28] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000428, active=true)
2022-08-06 12:02:41.508  INFO 11236 --- [      Thread-28] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000428, active=true)
2022-08-06 12:02:41.516  INFO 11236 --- [       Thread-4] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000429, active=true)
2022-08-06 12:02:46.526  INFO 11236 --- [       Thread-4] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000429, active=true)
2022-08-06 12:02:46.535  INFO 11236 --- [      Thread-10] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000431, active=true)
2022-08-06 12:02:46.544  INFO 11236 --- [      Thread-76] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000430, active=true)
2022-08-06 12:02:51.545  INFO 11236 --- [      Thread-10] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000431, active=true)
2022-08-06 12:02:51.556  INFO 11236 --- [      Thread-76] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000430, active=true)
2022-08-06 12:02:51.556  INFO 11236 --- [       Thread-2] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000432, active=true)
2022-08-06 12:02:56.570  INFO 11236 --- [       Thread-2] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000432, active=true)
2022-08-06 12:02:56.580  INFO 11236 --- [       Thread-6] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000433, active=true)
2022-08-06 12:03:01.592  INFO 11236 --- [       Thread-6] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000433, active=true)
2022-08-06 12:03:01.602  INFO 11236 --- [      Thread-12] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000434, active=true)
2022-08-06 12:03:06.612  INFO 11236 --- [      Thread-12] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000434, active=true)
2022-08-06 12:03:06.623  INFO 11236 --- [      Thread-72] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000435, active=true)
2022-08-06 12:03:11.632  INFO 11236 --- [      Thread-72] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000435, active=true)
2022-08-06 12:03:11.643  INFO 11236 --- [      Thread-56] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000439, active=true)
2022-08-06 12:03:11.651  INFO 11236 --- [      Thread-60] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000438, active=true)
2022-08-06 12:03:11.660  INFO 11236 --- [      Thread-68] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000436, active=true)
2022-08-06 12:03:11.672  INFO 11236 --- [      Thread-64] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000437, active=true)
2022-08-06 12:03:16.660  INFO 11236 --- [      Thread-56] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000439, active=true)
2022-08-06 12:03:16.666  INFO 11236 --- [      Thread-60] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000438, active=true)
2022-08-06 12:03:16.674  INFO 11236 --- [      Thread-68] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000436, active=true)
2022-08-06 12:03:16.681  INFO 11236 --- [      Thread-64] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000437, active=true)
2022-08-06 12:03:16.691  INFO 11236 --- [      Thread-52] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000440, active=true)
2022-08-06 12:03:21.701  INFO 11236 --- [      Thread-52] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000440, active=true)
2022-08-06 12:03:21.716  INFO 11236 --- [      Thread-48] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000441, active=true)
2022-08-06 12:03:26.727  INFO 11236 --- [      Thread-48] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000441, active=true)
2022-08-06 12:03:26.747  INFO 11236 --- [      Thread-40] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000442, active=true)
2022-08-06 12:03:31.790  INFO 11236 --- [      Thread-40] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000442, active=true)
2022-08-06 12:03:31.802  INFO 11236 --- [      Thread-20] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000443, active=true)
2022-08-06 12:03:36.816  INFO 11236 --- [      Thread-20] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000443, active=true)
2022-08-06 12:03:36.829  INFO 11236 --- [      Thread-81] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000444, active=true)
2022-08-06 12:03:41.906  INFO 11236 --- [      Thread-81] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000444, active=true)
2022-08-06 12:03:41.917  INFO 11236 --- [      Thread-85] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000445, active=true)
2022-08-06 12:03:46.933  INFO 11236 --- [      Thread-85] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000445, active=true)
2022-08-06 12:03:46.944  INFO 11236 --- [      Thread-95] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000446, active=true)
2022-08-06 12:03:46.952  INFO 11236 --- [      Thread-91] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000447, active=true)
2022-08-06 12:03:51.960  INFO 11236 --- [      Thread-95] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000446, active=true)
2022-08-06 12:03:51.963  INFO 11236 --- [      Thread-91] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000447, active=true)
2022-08-06 12:03:51.972  INFO 11236 --- [      Thread-87] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000448, active=true)
2022-08-06 12:03:56.983  INFO 11236 --- [      Thread-87] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000448, active=true)
2022-08-06 12:03:56.994  INFO 11236 --- [      Thread-83] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000449, active=true)
2022-08-06 12:04:02.009  INFO 11236 --- [      Thread-83] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000449, active=true)
2022-08-06 12:04:02.019  INFO 11236 --- [     Thread-100] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000450, active=true)
2022-08-06 12:04:07.030  INFO 11236 --- [     Thread-100] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000450, active=true)
2022-08-06 12:04:07.042  INFO 11236 --- [      Thread-96] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000451, active=true)
2022-08-06 12:04:12.111  INFO 11236 --- [      Thread-96] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000451, active=true)
2022-08-06 12:04:12.119  INFO 11236 --- [      Thread-92] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000452, active=true)
2022-08-06 12:04:17.154  INFO 11236 --- [      Thread-92] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000452, active=true)
2022-08-06 12:04:17.165  INFO 11236 --- [      Thread-88] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000453, active=true)
2022-08-06 12:04:22.176  INFO 11236 --- [      Thread-88] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000453, active=true)
2022-08-06 12:04:22.186  INFO 11236 --- [      Thread-84] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000454, active=true)
2022-08-06 12:04:27.197  INFO 11236 --- [      Thread-84] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000454, active=true)
2022-08-06 12:04:27.211  INFO 11236 --- [      Thread-80] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000455, active=true)
2022-08-06 12:04:32.223  INFO 11236 --- [      Thread-80] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000455, active=true)
2022-08-06 12:04:32.233  INFO 11236 --- [      Thread-98] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000456, active=true)
2022-08-06 12:04:37.245  INFO 11236 --- [      Thread-98] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000456, active=true)
2022-08-06 12:04:37.260  INFO 11236 --- [      Thread-94] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000457, active=true)
2022-08-06 12:04:42.274  INFO 11236 --- [      Thread-94] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000457, active=true)
2022-08-06 12:04:42.283  INFO 11236 --- [      Thread-90] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000458, active=true)
2022-08-06 12:04:47.301  INFO 11236 --- [      Thread-90] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000458, active=true)
2022-08-06 12:04:47.309  INFO 11236 --- [      Thread-86] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000459, active=true)
2022-08-06 12:04:47.324  INFO 11236 --- [      Thread-82] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000460, active=true)
2022-08-06 12:04:52.321  INFO 11236 --- [      Thread-86] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000459, active=true)
2022-08-06 12:04:52.334  INFO 11236 --- [      Thread-82] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000460, active=true)
2022-08-06 12:04:52.344  INFO 11236 --- [     Thread-101] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000461, active=true)
2022-08-06 12:04:57.353  INFO 11236 --- [     Thread-101] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000461, active=true)
2022-08-06 12:04:57.367  INFO 11236 --- [      Thread-97] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=READ, path=/test-lock/READ0000000462, active=true)
2022-08-06 12:05:02.377  INFO 11236 --- [      Thread-97] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=READ, path=/test-lock/READ0000000462, active=true)
2022-08-06 12:05:02.385  INFO 11236 --- [      Thread-93] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000463, active=true)
2022-08-06 12:05:07.394  INFO 11236 --- [      Thread-93] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000463, active=true)
2022-08-06 12:05:07.403  INFO 11236 --- [      Thread-99] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000464, active=true)
2022-08-06 12:05:12.412  INFO 11236 --- [      Thread-99] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000464, active=true)
2022-08-06 12:05:12.427  INFO 11236 --- [      Thread-89] com.ribbon.demo.DemoApplicationTests     : ---------成功获取锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000465, active=true)
2022-08-06 12:05:17.457  INFO 11236 --- [      Thread-89] com.ribbon.demo.DemoApplicationTests     : ---------释放锁:LockNode(lockId=WRITE, path=/test-lock/WRITE0000000465, active=true)

你可能感兴趣的:(zookeeper,分布式,java-zookeeper,zookeeper)

GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
01-Git初识 Meereen Git git
01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
Kafka是如何保证数据的安全性、可靠性和分区的喜欢猪猪 kafka 分布式
Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
浅谈MapReduce Android路上的人 Hadoop 分布式计算 mapreduce 分布式框架 hadoop
从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
KVM+GFS分布式存储系统构建KVM高可用 henan程序媛分布式 GFS 高可用 KVM
一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
Hadoop 傲雪凌霜，松柏长青后端大数据 hadoop 大数据分布式
ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
大模型训练数据库Common Crawl WindyChanChan 数据集语言模型数据库
CommonCrawl介绍‌‌CommonCrawl是一个非营利组织，致力于通过大规模分布式爬虫系统定期抓取整个Web并将其存储在一个可公开访问的数据库中。CommonCrawl的数据收集和处理过程包括使用Python开源爬虫工具收集全球范围内的网站数据，并将其上传到‌CommonCrawl基金会的数据仓库中。该项目从2008年开始，至今已经积累了大量的原始网页数据、元数据和文本提取数据。这些数据
慢速连接攻击是什么？慢速连接攻击怎么防护？快快小毛毛网络 ddos 服务器
慢速连接攻击（SlowConnectionAttack），又称慢速攻击（SlowlorisAttack），是一种网络攻击技术，旨在通过占用服务器上的所有可用连接资源来使其无法响应正常请求。与传统的拒绝服务（DoS）和分布式拒绝服务（DDoS）攻击不同，慢速攻击并不依赖于发送大量数据包来消耗带宽，而是利用HTTP、TCP或SSL等协议的特性，通过发送大量不完整的请求或缓慢发送数据来占用服务器资源，使
分布式锁和spring事务管理暴躁的鱼锁及事务分布式 spring java
最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
Gobelieve 架构 weixin_34099526 数据库 golang json
Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
Kafka详细解析与应用分析芊言芊语 kafka 分布式
Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
linux挂载文件夹小码快撩 linux
1.使用NFS（NetworkFileSystem）NFS是一种分布式文件系统协议，允许一个系统将其文件系统的一部分共享给其他系统。检查是否安装NFSrpm-qa|grepnfs2.启动和启用NFS服务假设服务名称为nfs-server.service，你可以使用以下命令启动和启用它：sudosystemctlstartnfs-server.servicesudosystemctlenablenf
Kafka 基础与架构理解 StaticKing KAFKA kafka
目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理朱杰jjj 缓存分布式
分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
机电综合管理系统架构小熊coder 机载系统系统架构
文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
华为云分布式缓存服务DCS与开源服务差异对比 hcinfo_18 redis使用华为云 Redis5.0 分布式缓存服务 Redis客户端
分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
Dubbo架构概览：服务注册与发现、远程调用、监控与管理木南曌 dubbo 架构
Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
nfs服务搭建 GHope
nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
hbase介绍 CrazyL- 云计算+大数据 hbase
hbase是一个分布式的、多版本的、面向列的开源数据库hbase利用hadoophdfs作为其文件存储系统，提供高可靠性、高性能、列存储、可伸缩、实时读写、适用于非结构化数据存储的数据库系统hbase利用hadoopmapreduce来处理hbase、中的海量数据hbase利用zookeeper作为分布式系统服务特点：数据量大：一个表可以有上亿行，上百万列（列多时，插入变慢）面向列：面向列（族）的
Flume：大规模日志收集与数据传输的利器傲雪凌霜，松柏长青后端大数据 flume 大数据
Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
探索未来，大规模分布式深度强化学习——深入解析IMPALA架构汤萌妮Margaret
探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp
Docker安装Kafka和Kafka-Manager 阿靖哦
本文介绍如何通过Docker安装kafka与kafka界面管理界面一、拉取zookeeper由于kafka需要依赖于zookeeper，因此这里先运行zookeeper1、拉取镜像dockerpullwurstmeister/zookeeper2、启动dockerrun-d--namezookeeper-p2181:2181-eTZ="Asia/Shanghai"--restartalwayswu
主流行架构 rainbowcheng 架构架构
nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
等保测评中的关键技术挑战与应对策略亿林数据网络安全等保测评
在信息安全领域，等保测评（信息安全等级保护测评）作为确保信息系统安全性的重要手段，其过程中不可避免地会遇到一系列技术挑战。这些挑战不仅考验着企业的技术实力，也对其安全管理水平提出了更高要求。本文将深入探讨等保测评中的关键技术挑战，并提出相应的应对策略。一、等保测评中的关键技术挑战1.复杂系统架构的评估难度随着信息技术的快速发展，企业信息系统的架构日益复杂，包括分布式系统、微服务架构、云计算环境等。
系统架构师软考历年论文题目（2009-2024年）及分析 pccai-vip 系统架构师系统架构
时间题目20091.论基于DSSA的软件架构设计与应用；2.论信息系统建模方法；3.论基于REST服务的Web应用系统设计；4.论软件可靠性设计与应用20101.论软件的静态演化和动态演化及其应用；2.论数据挖掘技术的应用；3.论大规模分布式系统缓存设计策略；4.论软件可靠性评价20111.论模型驱动架构在系统开发中的应用；2.论企业集成平台的架构设计；3.论企业架构管理与应用；4.论软件需求获取
深入解析 Dubbo 的 attachments 机制及其应用场景 molashaonian dubbo attachments 隐式传参
背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
座舱交互的下一个时代高工智能汽车交互物联网人工智能
为了满足座舱信息娱乐的更高性能要求，几乎所有的一线品牌都在准备“换芯”。去年开始，不少车型开始推动传统的分布式座舱仪表和中控电子架构进入域控制器时代，高通成为大赢家。今年6月，特斯拉也正式官宣，即将推出的新款ModelS将配备能够运行PS5游戏机性能的AMD芯片，包括专门定制的AMDRyzenCPU和独立的Navi23图形处理器。最新消息，特斯拉将率先在中国市场生产的ModelY高性能版车型换装A
继之前的线程循环加到窗口中运行 3213213333332132 java thread JFrame JPanel
之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
linux 常用命令 BlueSkator linux 命令
1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。但之前总是习惯于使用（grep -n 关键字文件名）查出关键字以及该关键字所在的行数，然后再用（sed -n '100,200p' 文件名），去查出该关键字之后的日志内容。但其实还有更简便的办法，就是用（grep -B n、-A n、-C n 关键
php heredoc原文档和nowdoc语法 dcj3sjt126com PHP heredoc nowdoc
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
overflow的属性周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
《我所了解的Java》——总体目录 g21121 java
准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 &n
[简单]docx4j常用方法小结 53873039oycg docx
本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: import java.io.File; import java.io.FileInputStream; import ja
Spring配置学习云端月影 spring配置
首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
Java新手入门的30个基本概念三 aijuans java 新手 java 入门
17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理 IBM 活动
我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
PL/SQL的过程编程,异常,声明变量,PL/SQL块百合不是茶 PL/SQL的过程编程异常 PL/SQL块声明变量
PL/SQL; 过程; 符号; 变量; PL/SQL块; 输出; 异常; PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
Mockito(三)--完整功能介绍 bijian1013 持续集成 mockito 单元测试
mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle 数据库 plsql
/* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
【Linux常用命令一】grep命令 bit1129 Linux常用命令
grep命令格式 grep [option] pattern [file-list] grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
mybatis3入门学习笔记白糖_ sql ibatis qq jdbc 配置管理
MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。 MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
Linux 命令神器：lsof 入门 ronin47 lsof
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。有趣的是，lsof也是有着最多
java实现两个大数相加，可能存在溢出。 bylijinnan java实现
import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
Kettle学习资料分享 Kettle 3.2 使用说明书目录概述..........................................................................................................................................7 1.Kettle 资源库管
[货币与金融]钢之炼金术士 comsci 金融
自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 炼金术这个古老
Toast原来也可以多样化 dai_lm android toast
Style 1：默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2：顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
java数据计算的几种解决方法3 datamachine java hadoop ibatis r-langue r
4、iBatis 简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
向网页中插入透明Flash的方法和技巧 dcj3sjt126com html Web Flash
将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制：　　注意wmode="transparent"是控制Flash是否透明
ios UICollectionView的使用 dcj3sjt126com
UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
Eos平台java公共逻辑蕃薯耀 Eos平台java公共逻辑 Eos平台 java公共逻辑
Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 applicationContext-MvcConfig.xml  <
解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码，因此必须综合判断，编写一个工具类： /** * * @Title: pro
挥洒泪水的青春 lampcy 编程生活程序员
2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScript iframe contentDocument 高度自适应局部刷新
如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
用Rapael做图表 tntxia rap
function drawReport(paper,attr,data){ var width = attr.width; var height = attr.height; var max = 0; &nbs
HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5 bootstrap
<!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">