ZooKeeper实现分布式队列、分布式锁和选举详解

news2024/11/28 0:37:27

提示：本文章非原创，记录一下优秀的干货。
[原创参考]：https://blog.csdn.net/qq_40378034/article/details/117014648

前言

ZooKeeper源码的zookeeper-recipes目录下提供了分布式队列、分布式锁和选举的实现GitHub地址。
本文主要对这几种实现做实现原理的解析和源码剖析.

一、分布式队列

使用路径为/queue的znode下的节点表示队列中的元素。
/queue下的节点都是顺序持久化znode, 这些znode名字的后缀数字表示了对应队列元素在队列中的位置。
znode名字后缀数字越小，对应队列元素在队列中的位置越靠前
在这里插入图片描述

  1. offer方法

offer方法在/queue下面创建一个顺序znode。因为znode的后缀数字是/queue下面现有znode最大后缀数字加1，所以该znode对应的队列元素处于队尾

public class DistributedQueue {
    public boolean offer(byte[] data) throws KeeperException, InterruptedException {
        for (; ; ) {
            try {
                zookeeper.create(dir + "/" + prefix, data, acl, CreateMode.PERSISTENT_SEQUENTIAL);
                return true;
            } catch (KeeperException.NoNodeException e) {
                zookeeper.create(dir, new byte[0], acl, CreateMode.PERSISTENT);
            }
        }
    }
  1. element方法
public class DistributedQueue {

    public byte[] element() throws NoSuchElementException, KeeperException, InterruptedException {
        Map<Long, String> orderedChildren;
        while (true) {
            try {
              	//获取所有排好序的子节点
                orderedChildren = orderedChildren(null);
            } catch (KeeperException.NoNodeException e) {
                throw new NoSuchElementException();
            }
            if (orderedChildren.size() == 0) {
                throw new NoSuchElementException();
            }
						//返回队头节点的数据
            for (String headNode : orderedChildren.values()) {
                if (headNode != null) {
                    try {
                        return zookeeper.getData(dir + "/" + headNode, false, null);
                    } catch (KeeperException.NoNodeException e) {
                      	//另一个客户端已经移除了队头节点,尝试获取下一个节点
                    }
                }
            }
        }
    }
  
    private Map<Long, String> orderedChildren(Watcher watcher) throws KeeperException, InterruptedException {
        Map<Long, String> orderedChildren = new TreeMap<>();
        List<String> childNames;
        childNames = zookeeper.getChildren(dir, watcher);

        for (String childName : childNames) {
            try {
                if (!childName.regionMatches(0, prefix, 0, prefix.length())) {
                    LOG.warn("Found child node with improper name: {}", childName);
                    continue;
                }
                String suffix = childName.substring(prefix.length());
                Long childId = Long.parseLong(suffix);
                orderedChildren.put(childId, childName);
            } catch (NumberFormatException e) {
                LOG.warn("Found child node with improper format : {}", childName, e);
            }
        }
        return orderedChildren;
    }
  1. remove方法
public class DistributedQueue {

    public byte[] remove() throws NoSuchElementException, KeeperException, InterruptedException {
        Map<Long, String> orderedChildren;
        while (true) {
            try {
              	//获取所有排好序的子节点
                orderedChildren = orderedChildren(null);
            } catch (KeeperException.NoNodeException e) {
                throw new NoSuchElementException();
            }
            if (orderedChildren.size() == 0) {
                throw new NoSuchElementException();
            }
						//移除队头节点
            for (String headNode : orderedChildren.values()) {
                String path = dir + "/" + headNode;
                try {
                    byte[] data = zookeeper.getData(path, false, null);
                    zookeeper.delete(path, -1);
                    return data;
                } catch (KeeperException.NoNodeException e) {
                    //另一个客户端已经移除了队头节点,尝试移除下一个节点
                }
            }
        }
    }

二、分布式锁

1.排他锁

排他锁的核心是如何保证当前有且仅有一个事务获取锁，并且锁被释放后，所有正在等待获取锁的事务都能够被通知到

定义锁
通过在ZooKeeper上创建一个子节点来表示一个锁，例如/exclusive_lock/lock 节点就可以被定义为一个锁
在这里插入图片描述
获取锁
在需要获取排他锁时，所有的客户端都会试图通过调用create()接口，在/exclusive_lock节点下创建临时子节点/exclusive_lock/lock。ZooKeeper会保证在所有的客户端中，最终只有一个客户能够创建成功，那么就可以认为该客户端获取了锁。同时，所有没有获取到锁的客户端就需要到/exclusive_lock节点上注册一个子节点变更的watcher监听，以便实时监听到lock节点的变更情况
释放锁
/exclusive_lock/lock是一个临时节点，因此在以下两种情况下，都有可能释放锁

  1. 当前获取锁的客户端机器发生宕机，那么ZooKeeper上的这个临时节点就会被移除
  2. 正常执行完业务逻辑后，客户端就会主动将自己创建的临时节点删除
    无论在什么情况下移除了lock节点，ZooKeeper都会通知所有在/exclusive_lock节点上注册了子节点变更watcher监听的客户端。
    这些客户端在接收到通知后，再次重新发起分布式锁获取，即重复获取锁过程。

羊群效应
上面的排他锁的实现可能引发羊群效应：当一个特定的znode改变的时候ZooKeeper触发了所有watcher的事件，由于通知的客户端很多，所以通知操作会造成ZooKeeper性能突然下降，这样会影响ZooKeeper的使用

改进后的分布式锁实现

获取锁

首先，在Zookeeper当中创建一个持久节点ParentLock。当第一个客户端想要获得锁时，需要在ParentLock这个节点下面创建一个临时顺序节点Lock1
在这里插入图片描述
之后，Client1查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock1是不是顺序最靠前的一个。如果是第一个节点，则成功获得锁
在这里插入图片描述
这时候，如果再有一个客户端Client2前来获取锁，则在ParentLock下再创建一个临时顺序节点Lock2
在这里插入图片描述
Client2查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock2是不是顺序最靠前的一个，结果发现节点Lock2并不是最小的,于是，Client2向排序仅比它靠前的节点Lock1注册watcher，用于监听Lock1节点是否存在。
这意味着Client2抢锁失败，进入了等待状态
在这里插入图片描述
这时候，如果又有一个客户端Client3前来获取锁，则在ParentLock下再创建一个临时顺序节点Lock3
在这里插入图片描述
Client3查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock3是不是顺序最靠前的一个，结果同样发现节点Lock3并不是最小的

于是，Client3向排序仅比它靠前的节点Lock2注册watcher，用于监听Lock2节点是否存在。这意味着Client3同样抢锁失败，进入了等待状态
在这里插入图片描述
这样一来，Client1得到了锁，Client2监听了Lock1，Client3监听了Lock2。这恰恰形成了一个等待队列，很像是Java当中ReentrantLock所依赖的AQS

释放锁

释放锁分为两种情况：

1.任务完成，客户端显示释放：当任务完成时，Client1会显示调用删除节点Lock1的指令
在这里插入图片描述
2.任务执行过程中，客户端崩溃

获得锁的Client1在任务执行过程中，如果客户端崩溃，则会断开与Zookeeper服务端的连接。根据临时节点的特性，相关联的节点Lock1会随之自动删除
在这里插入图片描述
由于Client2一直监听着Lock1的存在状态，当Lock1节点被删除，Client2会立刻收到通知。这时候Client2会再次查询ParentLock下面的所有节点，确认自己创建的节点Lock2是不是目前最小的节点。如果是最小，则Client2获得了锁
在这里插入图片描述
同理，如果Client2也因为任务完成或者节点崩溃而删除了节点Lock2，那么Client3就会接到通知
在这里插入图片描述
最终，Client3成功得到了锁
在这里插入图片描述

2.共享锁

共享锁又称为读锁，在同一时刻可以允许多个线程访问，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁确实每次只能被独占

定义锁

和排他锁一样，同样是通过ZooKeeper上的数据节点来表示一个锁，是一个类似于/shared_lock/[Hostname]-请求类型-序号的临时顺序节点，例如/shared_lock/192.168.0.1-R-0000000001，那么，这个节点就代表了一个共享锁，如下图所示：
在这里插入图片描述
获取锁

在需要获取共享锁时，所有客户端都会到/shared_lock这个节点下面创建一个临时顺序节点，如果当前是读请求，那么就创建。例如/shared_lock/192.168.0.1-R-0000000001的节点；如果是写请求，那么就创建例如/shared_lock/192.168.0.1-W-0000000001的节点

判断读写顺序

每个锁竞争者，只需要关注/shared_lock节点下序号比自己小的那个节点是否存在即可，具体实现如下：

1）客户端调用create()方法创建一个类似于/shared_lock/[Hostname]-请求类型-序号的临时顺序节点

2）客户端调用getChildren()接口来获取所有已经创建的子节点列表

3）判断是否可以获取共享锁：
读请求：没有比自己序号小的节点或者所有比自己序号小的节点都是读请求
写请求：序号是否最小

4）如果无法获取共享锁，那么就调用exist()来对比自己小的那个节点注册watcher

读请求：向比自己序号小的最后一个写请求节点注册watcher监听
写请求：向比自己序号小的最后一个节点注册watcher监听

5）等待watcher通知，继续进入步骤2

释放锁

释放锁的逻辑和排他锁是一致的

整个共享锁的获取和释放流程如下图：
在这里插入图片描述

排他锁源码解析
1）加锁过程

public class WriteLock extends ProtocolSupport {
    public synchronized boolean lock() throws KeeperException, InterruptedException {
        if (isClosed()) {
            return false;
        }
      	//确认持久父节点是否存在
        ensurePathExists(dir);
      	//真正获取锁的逻辑 调用ProtocolSupport的retryOperation()方法
        return (Boolean) retryOperation(zop);
    }
 }

class ProtocolSupport {
    protected Object retryOperation(ZooKeeperOperation operation)
        throws KeeperException, InterruptedException {
        KeeperException exception = null;
        for (int i = 0; i < RETRY_COUNT; i++) {
            try {
              	//调用LockZooKeeperOperation的execute()方法
                return operation.execute();
            } catch (KeeperException.SessionExpiredException e) {
                LOG.warn("Session expired {}. Reconnecting...", zookeeper, e);
                throw e;
            } catch (KeeperException.ConnectionLossException e) {
                if (exception == null) {
                    exception = e;
                }
                LOG.debug("Attempt {} failed with connection loss. Reconnecting...", i);
                retryDelay(i);
            }
        }
        throw exception;
    }

public class WriteLock extends ProtocolSupport {
    private class LockZooKeeperOperation implements ZooKeeperOperation {
        private void findPrefixInChildren(String prefix, ZooKeeper zookeeper, String dir)
            throws KeeperException, InterruptedException {
            List<String> names = zookeeper.getChildren(dir, false);
            for (String name : names) {
                if (name.startsWith(prefix)) {
                    id = name;
                    LOG.debug("Found id created last time: {}", id);
                    break;
                }
            }
            if (id == null) {
                id = zookeeper.create(dir + "/" + prefix, data, getAcl(), EPHEMERAL_SEQUENTIAL);
                LOG.debug("Created id: {}", id);
            }
        }

        @SuppressFBWarnings(
            value = "NP_NULL_PARAM_DEREF_NONVIRTUAL",
            justification = "findPrefixInChildren will assign a value to this.id")
        public boolean execute() throws KeeperException, InterruptedException {
            do {
                if (id == null) {
                    long sessionId = zookeeper.getSessionId();
                    String prefix = "x-" + sessionId + "-";
                  	//创建临时顺序节点
                    findPrefixInChildren(prefix, zookeeper, dir);
                    idName = new ZNodeName(id);
                }
              	//获取所有子节点
                List<String> names = zookeeper.getChildren(dir, false);
                if (names.isEmpty()) {
                    LOG.warn("No children in: {} when we've just created one! Lets recreate it...", dir);
                    id = null;
                } else {
                  	//对所有子节点进行排序
                    SortedSet<ZNodeName> sortedNames = new TreeSet<>();
                    for (String name : names) {
                        sortedNames.add(new ZNodeName(dir + "/" + name));
                    }
                    ownerId = sortedNames.first().getName();
                    SortedSet<ZNodeName> lessThanMe = sortedNames.headSet(idName);
                  	//是否存在序号比自己小的节点
                    if (!lessThanMe.isEmpty()) {
                        ZNodeName lastChildName = lessThanMe.last();
                        lastChildId = lastChildName.getName();
                        LOG.debug("Watching less than me node: {}", lastChildId);
                      	//有序号比自己小的节点,则调用exist()向前一个节点注册watcher
                        Stat stat = zookeeper.exists(lastChildId, new LockWatcher());
                        if (stat != null) {
                            return Boolean.FALSE;
                        } else {
                            LOG.warn("Could not find the stats for less than me: {}", lastChildName.getName());
                        }
                    } 
                  	//没有序号比自己小的节点,则获取锁
                  	else {
                        if (isOwner()) {
                            LockListener lockListener = getLockListener();
                            if (lockListener != null) {
                                lockListener.lockAcquired();
                            }
                            return Boolean.TRUE;
                        }
                    }
                }
            }
            while (id == null);
            return Boolean.FALSE;
        }

2）解锁过程

public class WriteLock extends ProtocolSupport {

    public synchronized void unlock() throws RuntimeException {

        if (!isClosed() && id != null) {
            try {
								//删除当前节点,此时会触发后一个节点的watcher
                ZooKeeperOperation zopdel = () -> {
                    zookeeper.delete(id, -1);
                    return Boolean.TRUE;
                };
                zopdel.execute();
            } catch (InterruptedException e) {
                LOG.warn("Unexpected exception", e);
                Thread.currentThread().interrupt();
            } catch (KeeperException.NoNodeException e) {
            } catch (KeeperException e) {
                LOG.warn("Unexpected exception", e);
                throw new RuntimeException(e.getMessage(), e);
            } finally {
                LockListener lockListener = getLockListener();
                if (lockListener != null) {
                    lockListener.lockReleased();
                }
                id = null;
            }
        }
    }
}

参考：漫画：如何用Zookeeper实现分布式锁？

3、选举
使用临时顺序znode来表示选举请求，创建最小后缀数字znode的选举请求成功。在协同设计上和分布式锁是一样的，不同之处在于具体实现。不同于分布式锁，选举的具体实现对选举的各个阶段做了细致的监控

public class LeaderElectionSupport implements Watcher {    
    public synchronized void start() {
        state = State.START;
        dispatchEvent(EventType.START);
        LOG.info("Starting leader election support");
        if (zooKeeper == null) {
            throw new IllegalStateException(
                "No instance of zookeeper provided. Hint: use setZooKeeper()");
        }
        if (hostName == null) {
            throw new IllegalStateException(
                "No hostname provided. Hint: use setHostName()");
        }
        try {
          	//发起选举请求 创建临时顺序节点
            makeOffer();
          	//选举请求是否被满足
            determineElectionStatus();
        } catch (KeeperException | InterruptedException e) {
            becomeFailed(e);
        }
    }
  
    private void makeOffer() throws KeeperException, InterruptedException {
        state = State.OFFER;
        dispatchEvent(EventType.OFFER_START);
        LeaderOffer newLeaderOffer = new LeaderOffer();
        byte[] hostnameBytes;
        synchronized (this) {
            newLeaderOffer.setHostName(hostName);
            hostnameBytes = hostName.getBytes();
            newLeaderOffer.setNodePath(zooKeeper.create(rootNodeName + "/" + "n_",
                                                        hostnameBytes, ZooDefs.Ids.OPEN_ACL_UNSAFE,
                                                        CreateMode.EPHEMERAL_SEQUENTIAL));
            leaderOffer = newLeaderOffer;
        }
        LOG.debug("Created leader offer {}", leaderOffer);
        dispatchEvent(EventType.OFFER_COMPLETE);
    }
  
    private void determineElectionStatus() throws KeeperException, InterruptedException {
        state = State.DETERMINE;
        dispatchEvent(EventType.DETERMINE_START);
        LeaderOffer currentLeaderOffer = getLeaderOffer();
        String[] components = currentLeaderOffer.getNodePath().split("/");
        currentLeaderOffer.setId(Integer.valueOf(components[components.length - 1].substring("n_".length())));
				//获取所有子节点并排序
        List<LeaderOffer> leaderOffers = toLeaderOffers(zooKeeper.getChildren(rootNodeName, false));
        for (int i = 0; i < leaderOffers.size(); i++) {
            LeaderOffer leaderOffer = leaderOffers.get(i);
            if (leaderOffer.getId().equals(currentLeaderOffer.getId())) {
                LOG.debug("There are {} leader offers. I am {} in line.", leaderOffers.size(), i);
                dispatchEvent(EventType.DETERMINE_COMPLETE);		
              	//如果当前节点是第一个,则成为Leader
                if (i == 0) {
                    becomeLeader();
                } 
              	//如果有选举请求在当前节点前面,则进行等待,调用exist()向前一个节点注册watcher
              	else {
                    becomeReady(leaderOffers.get(i - 1));
                }
                break;
            }
        }
    }

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/364399.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

XXL-JOB怎么玩？

XXL-JOB怎么玩？

官网&#xff1a;https://www.xuxueli.com/xxl-job/文档&#xff1a;https://www.xuxueli.com/xxl-job/#%E3%80%8A%E5%88%86%E5%B8%83%E5%BC%8F%E4%BB%BB%E5%8A%A1%E8%B0%83%E5%BA%A6%E5%B9%B3%E5%8F%B0XXL-JOB%E3%80%8BXXL-JOB主要有调度中心、执行器、任务。开放源产品&#…
阅读更多...
数据的存储（2）——浮点型

数据的存储（2）——浮点型

前言&#xff1a;内容是关于浮点型在内存中的存储详解及例子 数据的存储&#xff08;1&#xff09;——整型&#xff08;点击即跳转&#xff09; 浮点数的存储规则 任意一个二进制浮点数可以表示成以下形式&#xff1a; (-1)^S * M * 2^E (-1)^S表示符号位&#xff0c;当S0…
阅读更多...
企业数字化转型该怎么做？有效工具有哪些？

企业数字化转型该怎么做？有效工具有哪些？

数字化转型的有效工具有哪些&#xff1f;简单来说&#xff0c;企业数字化转型的工具&#xff0c;可以划分为两大阶段—— 第一阶段是传统的IT软硬件&#xff0c;比如传统的ERP系统等第二阶段是与最新数字化技术相匹配的软硬件&#xff0c;比如“SaaS平台”、“低零代码平台”等…
阅读更多...
数据结构与算法基础-学习-13-线性表之链队

数据结构与算法基础-学习-13-线性表之链队

一、个人理解链队是线性表的衍生之一&#xff0c;具有先进先出的特性&#xff0c;在队尾进行插入操作&#xff0c;在队头进行删除操作。链队由于是动态扩容的&#xff0c;需要新的数据节点时&#xff0c;分配一个&#xff0c;所以不存在顺序队的真上溢情况。链队删除队头节点&a…
阅读更多...
点击化学交联剂1807518-78-0,Propargyl-PEG1-SS-PEG1-t-butyl ester,丙炔单乙二醇二硫键单乙二醇叔丁酯

点击化学交联剂1807518-78-0,Propargyl-PEG1-SS-PEG1-t-butyl ester,丙炔单乙二醇二硫键单乙二醇叔丁酯

1、基础产品数据&#xff08;Basic Product Data&#xff09;&#xff1a;CAS号&#xff1a;1807518-78-0中文名&#xff1a;丙炔-单乙二醇-二硫键-单乙二醇-叔丁酯英文名&#xff1a;Propargyl-PEG1-SS-PEG1-t-butyl ester 结构式&#xff08;Structural&#xff09;&#xff…
阅读更多...
176、【动态规划】leetcode ——1143. 最长公共子序列（C++版本）

176、【动态规划】leetcode ——1143. 最长公共子序列（C++版本）

题目描述 原题链接&#xff1a;1143. 最长公共子序列 题目描述 本题和 718. 最长重复子数组&#xff08;动态规划&#xff09; 的区别在于此时不要求令一个数组中元素连续。 动态规划五步曲&#xff1a; &#xff08;1&#xff09;dp[i][j]含义&#xff1a; 截止到text1[i …
阅读更多...
前端编译、JIT编译、AOT编译

前端编译、JIT编译、AOT编译

一、前端编译&#xff1a;java设计之初就是强调跨平台&#xff0c;通过javac将源文件编译成于平台无关的class文件&#xff0c; 它定义了执行 Java 程序所需的所有信息&#xff08;许多Java"语法糖"&#xff0c;是在这个阶段完成的&#xff0c;不依赖虚拟机&#xff…
阅读更多...
将多个springboot项目的pom.xml文件整合

将多个springboot项目的pom.xml文件整合

将多个springboot项目的pom.xml文件整合 0.0、前因 ​ 刚入公司敲代码时、发现一个项目中会包含多个子项目、每个子项目会代表一个功能模块、这属实是把我这个菜鸟惊叹到了。而这种分而治之的方式也引申出一个问题&#xff1a;各子项目的依赖如何统一管理&#xff1f; ​ 我…
阅读更多...
Linux:基于bufferevent epoll tcp客户端代码

Linux:基于bufferevent epoll tcp客户端代码

基于bufferevent epoll tcp客户端代码: include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <string.h> #include <event2/event.h> #include <event2/buffere…
阅读更多...
在外包干了几年，感觉自己都快费了

在外包干了几年，感觉自己都快费了

先说一下自己的情况。大专生&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近2年的点点点&#xff0c;今年年上旬&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落&#xff01;而我已经在一个企业干了五年的功能测试…
阅读更多...
JavaEE-初识Servlet

JavaEE-初识Servlet

目录Servlet 是什么?完成一个servlet程序1.创建一个maven项目2.引入依赖3.创建目录4.编写Servlet代码5.打包6.部署7.验证程序第三方工具简化Servlet 是什么? Servlet 是一种实现动态页面的技术. 是一组 Tomcat 提供给程序猿的 API, 帮助程序猿简单高效的开发一个 web app. …
阅读更多...
项目难点——【3】分布式任务调度、线程池使用、视频转换

项目难点——【3】分布式任务调度、线程池使用、视频转换

项目难点——【3】分布式任务调度、线程池使用、视频转换 我们有时候在处理视频文件的时候会遇到视频格式转换问题。 1 分布式任务调度 在项目开发中我们想要提升我们项目响应的速度或者想要服务器高效处理一批任务&#xff0c;这个时候就有两种方式&#xff1a; 多线程&#x…
阅读更多...
（18）目标检测算法之数据集标签格式转换：json2txt、xml2txt

（18）目标检测算法之数据集标签格式转换：json2txt、xml2txt

目标检测算法之数据集标签格式转换&#xff1a;json2txt、xml2txt 目标检测最常见的模型&#xff1a;YOLO&#xff0c;常见的几种标注方式&#xff1a;矩形框、旋转矩形框、实例分割中的多边形标注等类型&#xff0c;根据其标注标签&#xff0c;目标检测主要有以下两种转换方式…
阅读更多...
快速读懂网络拓扑图

快速读懂网络拓扑图

快速读懂网络拓扑图几重常见的网络拓扑总线型拓扑简介优点缺点环型拓扑简介优点缺点星型拓扑简介优点缺点网络层级机构节点结点链路通路不同的连接线代表什么意思&#xff1f;不同颜色、粗细的直线代表什么意思&#xff1f;闪电线-串行链路几重常见的网络拓扑 总线型拓扑 简介…
阅读更多...
创建项目(React+umi+typeScript)

创建项目(React+umi+typeScript)

项目框架搭建的方式react脚手架Ant-design官网一、安装方式npm二、安装方式yarn三、安装方式umi devreact脚手架 命令行&#xff1a; npx create-react-app myReactName项目目录结构&#xff1a; 浏览器运行&#xff0c;端口号3000&#xff1a; Ant-design官网 一、安装方…
阅读更多...
zk-STARK/zk-SNARK中IP，PCP，IPCP，IOP，PIOP，LIP，LPCP模型介绍

zk-STARK/zk-SNARK中IP，PCP，IPCP，IOP，PIOP，LIP，LPCP模型介绍

我们的目标是构造 zkSNARK。在我们的目标场景中&#xff0c;Prover 只需要发送一个简短的证明字符串给 Verifier&#xff0c;而 Verifier 不需要给 Prover 发送任何消息。 直接构造一个满足这个场景的 zkSNARK 可能会很困难。一个更灵活的方式是在先在理想模型下构造证明系统&…
阅读更多...
SocketPro完整使用教程分享，手把手指导

SocketPro完整使用教程分享，手把手指导

SocketPro是一款外贸与跨境业务&#xff0c;设计师&#xff0c;海外留学生经常使用的工具。 那么&#xff0c;到底该如何使用SocketPro这款工具&#xff0c;实现自己的业务需求呢&#xff1f;这里放一个以前其他大佬关于SocketPro使用体验的测评: 上面的SocketPro使用测评&…
阅读更多...
【Java并发编程】线程安全（一）Synchronized原理

【Java并发编程】线程安全（一）Synchronized原理

Synchronized底层实现 简单来说&#xff0c;Synchronized关键字的执行主体是线程对象&#xff0c;加锁是通过一个锁对象来完成的是&#xff0c;而锁对象底层关联了一个c源码的monitor的对象&#xff0c;monitor对象底层又对应了操作系统级别的互斥锁&#xff0c;同一时刻只有一…
阅读更多...
历时半年，我终于阿里上岸了，附面经和Java非科班学习心得

历时半年，我终于阿里上岸了，附面经和Java非科班学习心得

个人经历 本科双非化学&#xff0c;跨考了电子硕士&#xff0c;研究生依然双非。无互联网实习&#xff0c;无比赛无论文。&#xff08;研究生研究方向是车辆电子和楼宇自动化&#xff0c;有自动化和高校实训讲师相关的实习经历&#xff09; 21年11开始学Java准备秋招。 阿里上…
阅读更多...
你真的懂二分法吗？

你真的懂二分法吗？

二分法 二分法非常让我们头痛&#xff0c;不论对于初学者&#xff0c;还是对于有一定编程经验的人来讲&#xff0c;我们都会以为这个思想很简单&#xff0c;而不去在意&#xff0c;可是在实际运用中我们在处理边界条件的时候&#xff0c;往往会要不写出了死循环&#xff0c;要不…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023