一致性哈希算法

最新推荐文章于 2022-07-17 21:13:20 发布
最新推荐文章于 2022-07-17 21:13:20 发布
阅读量1k 收藏
点赞数 1
分类专栏： 算法与数据结构 文章标签： 哈希算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014106644/article/details/122747005
版权

       有一堆待执行的任务(N个)  有一机器集群(M个)，怎样分配任务最佳，使得每台机器分到的任务数尽量均衡，当机器集群数量发生变化时，任务数还是尽量平均分配，并且对于已分配的任务尽量减少再次分配，减少任务移动的成本。

直接哈希取余算法

选择任务的某一特征值，哈希取余来分配任务，第i个任务的特征为hash(i) 则其应该分配到机器编号为    hash(i)%M

优点：分配方式简单

缺点：特征值和哈希算法的选择非常重要，否则任务会分配不均衡，极端情况会分配到同一台机器；

当机器的数量发生变化时，增加或者减少，此时M值发生变化，为了保证负载均衡，需要重新进行计算，大部分任务都移动重新分配到其他机器，移动成本太高。

一致性哈希算法

现在来看看一致性哈希算法是如何解决该问题的，首先特征值和哈希算法的选择可以使用业界已有优秀的哈希算法 FNV1_32_HASH、KETAMA_HASH

任务N个 0<i<N  机器 M个  0<j<M

任务i的哈希值 hash(i)  机器j的哈希值  hash(j)

一致性哈希分配策略

将M个机器依次计算哈希值 防止于一个0-2^32-1的环上，使用优秀的哈希算法可以保证M个机器在环上的分配尽可能的均匀。

对于每一个任务I 计算hash(i) 将其置于环上，顺时针找到第一个机器节点即为该任务待分配的物理节点。

如下所示

 

 假定机器编号为 t1  t2  t3 任务编号为 k1  k2  k3  k4

按照选择规则可知任务分配策略为

任务

K1

K2

K3

K4

机器

T1

T2

K1

T3

顺时针寻找 即寻找比hash(i)大的最小的hash(j)机器编号

如果找不到 则取机器0号(K3情况)

机器数量增加

如果增加机器T4 则任务K3需要重新分配 由原来的T1变为T4 其他任务不需要重新分配，即每增加一台机器，需要改动的任务约占N*(1/M)

 

机器数量减少

如果机器T3下线，则任务K4需要由原来的T3变为T2,即需要改动的任务约占N*(1/M)

 

虚拟节点

当机器数量增加时，T4增加 只是将T1的负载分担一部分，T2和 T3并没有因为 T4的加入而减少负载压力。

 可以通过引入虚拟节点来解决负载不均衡的问题。即将每台物理服务器虚拟为一组虚拟服务器，将虚拟服务器放置到哈希环上，如果要确定对象的服务器，需先确定对象的虚拟服务器，再由虚拟服务器确定物理服务器。

对于每一台物理机器，增加了很多虚拟节点 这样当增加一台机器时，会增加很多虚拟节点，这些虚拟节点会尽可能分部在哈希环上，分担尽可能多的任务负载。

下面是机器数和虚拟节点数的一些最佳实践，横轴为机器数 纵轴为虚拟节点数

假定10台机器  100000个任务  研究一下各种算法下 机器数量增加减少时，任务分配情况如何变化

一致性哈希算法编码实践

代码如下：

/**
 * 一致性哈希算法
 *
 * @author c00522789
 * @since 2022/1/22
 */
public class ConsistentHashLoadBalanceNoVirtualNode {

    private TreeMap<Long, String> realNodes = new TreeMap<>();

    private String[] nodes;

    public ConsistentHashLoadBalanceNoVirtualNode(String[] nodes) {
        this.nodes = Arrays.copyOf(nodes, nodes.length);
        init();
    }

    private void init() {
        for (String nodeName: nodes) {
            realNodes.put(hash(nodeName, 0), nodeName);
        }
    }

    private Long hash(String nodeName, int number) {
        byte[] digest = md5(nodeName);
        return (((long) (digest[3 + number * 4] & 0xFF) << 24)
                         | ((long) (digest[2 + number * 4] & 0xFF) << 16)
                         | ((long) (digest[1 + number * 4] & 0xFF) << 8)
                         | (digest[number * 4] & 0xFF))
                         & 0xFFFFFFFFL;
    }

    public String selectNode(String key) {
        Long hashKey = hash(key, 0);
        if (realNodes.containsKey(hashKey)) {
            return realNodes.get(hashKey);
        }
        // 比hashKey大的最小值
        Map.Entry<Long, String> entry = realNodes.ceilingEntry(hashKey);
        if (entry == null) {
            return nodes[0];
        }
        return entry.getValue();
    }

    private void printTreeNode() {
        if (realNodes == null || realNodes.isEmpty()) {
            System.out.println("empty");
            return;
        }
        realNodes.forEach((hashKey, node) -> {
            System.out.println(new StringBuffer().append(node).append("==>").append(hashKey));
        });
    }

    /**
     * 负载分配算法
     * 任务尽可能分配均衡
     * 机器减少时  任务重新分配  尽量均衡  已分配的任务尽量少的重新分配
     * 机器增加时  任务重新分配  尽量均衡  已分配的任务尽量少的重新分配
     * */
    public static void main(String[] args) {
       decrease();

       increase();

    }

    private static void decrease() {
        String[] nodes = new String[10];
        for (int n=0; n<10; n++) {
            nodes[n] = "192.168.2." + n + ":8080";
        }
        for (int n=10; n>0; n--) {
            ConsistentHashLoadBalanceNoVirtualNode consistentHash =
                    new ConsistentHashLoadBalanceNoVirtualNode(Arrays.copyOf(nodes, n));
            Map<String, Integer> map = new HashMap<>();
            for (int i=0; i<100000; i++) {
                String key = consistentHash.selectNode(String.valueOf(i));
                map.put(key, map.getOrDefault(key, 0) + 1);
            }
            System.out.println(map);
        }
    }

    private static void increase() {
        String[] nodes = new String[10];
        for (int n=0; n<10; n++) {
            nodes[n] = "192.168.2." + n + ":8080";
        }
        for (int n=1; n<=10; n++) {
            ConsistentHashLoadBalanceNoVirtualNode consistentHash =
                    new ConsistentHashLoadBalanceNoVirtualNode(Arrays.copyOf(nodes, n));
            // consistentHash.printTreeNode();
            Map<String, Integer> map = new HashMap<>();
            for (int i=0; i<100000; i++) {
                String key = consistentHash.selectNode(String.valueOf(i));
                map.put(key, map.getOrDefault(key, 0) + 1);
            }
            System.out.println(map);
        }
    }
}

运算结果如下：

机器数由10台逐渐减少

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=19770, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.9:8080=2694, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.8:8080=3848, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=22464, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.8:8080=3848, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=26312, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.1:8080=26312, 192.168.2.6:8080=8536, 192.168.2.2:8080=19743, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.1:8080=26312, 192.168.2.2:8080=19743, 192.168.2.3:8080=9260, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.1:8080=26312, 192.168.2.2:8080=19743, 192.168.2.3:8080=26808, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.1:8080=35196, 192.168.2.2:8080=19743, 192.168.2.3:8080=26808, 192.168.2.0:8080=18253}

{192.168.2.1:8080=62004, 192.168.2.2:8080=19743, 192.168.2.0:8080=18253}

{192.168.2.1:8080=62004, 192.168.2.0:8080=37996}

{192.168.2.0:8080=100000}

10台机器逐渐增加

{192.168.2.0:8080=100000}

{192.168.2.1:8080=62004, 192.168.2.0:8080=37996}

{192.168.2.1:8080=62004, 192.168.2.2:8080=19743, 192.168.2.0:8080=18253}

{192.168.2.1:8080=35196, 192.168.2.2:8080=19743, 192.168.2.3:8080=26808, 192.168.2.0:8080=18253}

{192.168.2.1:8080=26312, 192.168.2.2:8080=19743, 192.168.2.3:8080=26808, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.1:8080=26312, 192.168.2.2:8080=19743, 192.168.2.3:8080=9260, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.1:8080=26312, 192.168.2.6:8080=8536, 192.168.2.2:8080=19743, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=26312, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=22464, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.8:8080=3848, 192.168.2.4:8080=8884}

{192.168.2.5:8080=17548, 192.168.2.7:8080=17938, 192.168.2.1:8080=19770, 192.168.2.6:8080=8536, 192.168.2.2:8080=1805, 192.168.2.9:8080=2694, 192.168.2.3:8080=724, 192.168.2.0:8080=18253, 192.168.2.8:8080=3848, 192.168.2.4:8080=8884}

虚拟节点一致性哈希算法编码实践

代码如下：

/**
 * 一致性哈希算法--虚拟节点
 *
 * @author c00522789
 * @since 2022/1/22
 */
public class ConsistentHashLoadBalance {

    private TreeMap<Long, String> virtualNodes = new TreeMap<>();

    private LinkedList<String> nodes;

    // 每台物理机器的虚拟节点的数量
    private final int replicCnt;

    public ConsistentHashLoadBalance(LinkedList<String> nodes, int replicCnt) {
        this.nodes = nodes;
        this.replicCnt = replicCnt;
        init();
    }

    private void init() {
        for (String nodeName : nodes) {
            for (int i = 0; i < replicCnt / 4; i++) {
                String virtualNodeName = getNodeNameByIndex(nodeName, i);
                for (int j = 0; j < 4; j++) {
                    virtualNodes.put(hash(virtualNodeName, j), nodeName);
                }
            }
        }
    }

    private String getNodeNameByIndex(String nodeName, int index) {
        return new StringBuilder(nodeName).append("&&").append(index).toString();
    }

    private Long hash(String nodeName, int number) {
        byte[] digest = md5(nodeName);
        return (((long) (digest[3 + number * 4] & 0xFF) << 24) | ((long) (digest[2 + number * 4] & 0xFF) << 16) | (
                (long) (digest[1 + number * 4] & 0xFF) << 8) | (digest[number * 4] & 0xFF)) & 0xFFFFFFFFL;
    }

    public String selectNode(String key) {
        Long hashKey = hash(key, 0);
        if (virtualNodes.containsKey(hashKey)) {
            return virtualNodes.get(hashKey);
        }
        Map.Entry<Long, String> entry = virtualNodes.ceilingEntry(hashKey);
        if (entry == null) {
            return nodes.getFirst();
        }
        return entry.getValue();
    }

    private void printTreeNode() {
        if (virtualNodes == null || virtualNodes.isEmpty()) {
            System.out.println("empty");
            return;
        }
        virtualNodes.forEach((hashKey, node) -> {
            System.out.println(new StringBuffer().append(node).append("==>").append(hashKey));
        });
    }

    public static void main(String[] args) {
       decrease();

       increase();
    }

    private static void decrease() {
        LinkedList<String> nodes = new LinkedList<>();
        for (int n=0; n<10; n++) {
            nodes.add("192.168.2." + n + ":8080");
        }
        for (int n=10; n>1; n--) {
            nodes.removeLast();
            ConsistentHashLoadBalance consistentHash =
                    new ConsistentHashLoadBalance(nodes, 10);
            // consistentHash.printTreeNode();
            Map<String, Integer> map = new HashMap<>();
            for (int i=0; i<100000; i++) {
                String key = consistentHash.selectNode(String.valueOf(i));
                map.put(key, map.getOrDefault(key, 0) + 1);
            }
            System.out.println(map);
        }
    }

    private static void increase() {
        LinkedList<String> nodes = new LinkedList<>();
        for (int n=0; n<10; n++) {
            nodes.add("192.168.2." + n + ":8080");
            ConsistentHashLoadBalance consistentHash =
                    new ConsistentHashLoadBalance(nodes, 20);
            // consistentHash.printTreeNode();
            Map<String, Integer> map = new HashMap<>();
            for (int i=0; i<100000; i++) {
                String key = consistentHash.selectNode(String.valueOf(i));
                map.put(key, map.getOrDefault(key, 0) + 1);
            }
            System.out.println(map);
        }
    }
}

运算结果如下：

机器数由10台逐渐减少

{192.168.2.7:8080=12759, 192.168.2.5:8080=7687, 192.168.2.1:8080=8890, 192.168.2.6:8080=16898, 192.168.2.2:8080=8004, 192.168.2.3:8080=7663, 192.168.2.0:8080=8632, 192.168.2.4:8080=17784, 192.168.2.8:8080=11683}

{192.168.2.7:8080=13416, 192.168.2.5:8080=9166, 192.168.2.1:8080=11424, 192.168.2.6:8080=16898, 192.168.2.2:8080=8004, 192.168.2.3:8080=13427, 192.168.2.0:8080=9317, 192.168.2.4:8080=18348}

{192.168.2.5:8080=17508, 192.168.2.1:8080=15078, 192.168.2.6:8080=16898, 192.168.2.2:8080=8088, 192.168.2.3:8080=14274, 192.168.2.0:8080=9317, 192.168.2.4:8080=18837}

{192.168.2.5:8080=20414, 192.168.2.1:8080=15111, 192.168.2.2:8080=8088, 192.168.2.3:8080=14440, 192.168.2.0:8080=18607, 192.168.2.4:8080=23340}

{192.168.2.1:8080=17864, 192.168.2.2:8080=11225, 192.168.2.3:8080=14440, 192.168.2.0:8080=29163, 192.168.2.4:8080=27308}

{192.168.2.1:8080=17864, 192.168.2.2:8080=11225, 192.168.2.3:8080=29875, 192.168.2.0:8080=41036}

{192.168.2.1:8080=22396, 192.168.2.2:8080=32750, 192.168.2.0:8080=44854}

{192.168.2.1:8080=48076, 192.168.2.0:8080=51924}

{192.168.2.0:8080=100000}

10台机器逐渐增加

{192.168.2.0:8080=100000}

{192.168.2.1:8080=57930, 192.168.2.0:8080=42070}

{192.168.2.1:8080=39211, 192.168.2.2:8080=24515, 192.168.2.0:8080=36274}

{192.168.2.1:8080=32577, 192.168.2.2:8080=20091, 192.168.2.3:8080=18078, 192.168.2.0:8080=29254}

{192.168.2.1:8080=19092, 192.168.2.2:8080=18875, 192.168.2.3:8080=16774, 192.168.2.0:8080=18893, 192.168.2.4:8080=26366}

{192.168.2.5:8080=21527, 192.168.2.1:8080=16800, 192.168.2.2:8080=15388, 192.168.2.3:8080=15144, 192.168.2.0:8080=16051, 192.168.2.4:8080=15090}

{192.168.2.5:8080=16308, 192.168.2.1:8080=14945, 192.168.2.6:8080=14046, 192.168.2.2:8080=15388, 192.168.2.3:8080=13763, 192.168.2.0:8080=13438, 192.168.2.4:8080=12112}

{192.168.2.7:8080=10186, 192.168.2.5:8080=12335, 192.168.2.1:8080=14233, 192.168.2.6:8080=13941, 192.168.2.2:8080=15230, 192.168.2.3:8080=9747, 192.168.2.0:8080=13154, 192.168.2.4:8080=11174}

{192.168.2.7:8080=6703, 192.168.2.5:8080=11749, 192.168.2.1:8080=13619, 192.168.2.6:8080=12437, 192.168.2.2:8080=14236, 192.168.2.3:8080=9304, 192.168.2.0:8080=12259, 192.168.2.8:8080=10835, 192.168.2.4:8080=8858}

{192.168.2.7:8080=6172, 192.168.2.5:8080=10805, 192.168.2.1:8080=11395, 192.168.2.2:8080=13897, 192.168.2.6:8080=8876, 192.168.2.9:8080=10127, 192.168.2.3:8080=8671, 192.168.2.0:8080=11411, 192.168.2.8:8080=10321, 192.168.2.4:8080=8325}

可知使用虚拟节点算法 任务的分配能够更加均衡

参考文档

https://segmentfault.com/a/1190000021199728

一致性哈希算法原理分析及实现 - 滴水穿石，写自己的故事 - 博客园

一致性哈希算法之Ketama算法 - 简书

暗夜猎手-大魔王
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C# 实现的一致性哈希算法
04-30
一致性哈希算法是一种分布式哈希（Distributed Hash Table, DHT）技术，它解决了在分布式环境中数据分片和负载均衡的问题。在传统的哈希算法中，如果增加或减少服务器节点，会导致大量数据重新分配，而一致性哈希...
一致性哈希算法 consistent hashing
04-11
在分布式系统中，常常需要使用缓存，而且通常是集群，访问缓存和添加缓存都需要一个 hash 算法来寻找到合适的 Cache 节点。但，通常不是用取余hash，而是使用我们今天的主角—— 一致性 hash 算法。
一致性HASH（哈希）算法
wf_76的博客
07-02 317
一致性HASH（哈希）算法哈希算法一致性哈希算法服务器如何部署数据如何存储一致性哈希算法的容错性和可扩展性通过虚拟节点解决数据倾斜问题 哈希算法 在了解一致性哈希算法之前，让我们先了解一下哈希算法。 在现在大规模集群应用中，缓存是必不可少的一个标准开发配置。当缓存应用越来越多，越多越大，会应运而生分布式缓存系统。 那我们的缓存数据（k-v）如何均匀的分散到集群中呢？ 相关的算法有很多，如：轮循算法...
Android中的自定义View（二）
qq_37837621的博客
07-17 629
文章收藏的好句子：方向对了，慢其实就是快。ps：本篇文章的 demo 是用 AndroidStudio 工具开发的。这里在Android中的自定义View（一）这篇文章的基础上再继续写一下自定义 View 的案例，这里的自定义 ViewGroup 直接继承于 ViewGroup，我们写一个类似 ViewPager 这样的自定义 ViewGroup，可以让它左右滑动。（1）...
android imageview sc,Android_Android中通过反射实现圆角ImageView代码实例，private void init(){ paint = new Pa -...
weixin_35458714的博客
05-28 205
Android中通过反射实现圆角ImageView代码实例private void init(){paint = new Paint(Paint.ANTI_ALIAS_FLAG);roundRect = new RectF(0, 0, getWidth() , getHeight());radius = 40;mPorterDuffXfermode = new PorterDuffXfermode...
Android自定义控件开发入门与实战（15）SurfaceView
RikkaTheWorld
06-23 1672
SurfaceView
python 实现 一致性哈希算法
04-19
一致性哈希算法
一致性哈希算法以及其PHP实现详细解析
10-26
一致性哈希算法是一种在分布式系统中用于负载均衡的算法，特别是在缓存服务、数据库分片等领域广泛应用。它的主要目标是在动态增加或减少服务器数量时，尽可能地减少数据迁移的量，以保持系统的稳定性和效率。 在...
基于一致性哈希算法和Ckafka技术的IMS电话实时录音系统
05-06
其次介绍了系统的实现流程，阐明了系统的关键技术：利用录音服务器对其镜像端口的SIP报文进行解析获得媒体流并解码、采用一致性哈希算法的内存数据库作为解码数据的缓存机制、利用Ckafka技术在两者之间构建实时数据...
基于一致性哈希算法的分布式数据库高效扩展方法.pdf
08-08
#资源达人分享计划#
PHP实现的一致性哈希算法完整实例
10-23
主要介绍了PHP实现的一致性哈希算法,以完整实例形式分析了PHP哈希算法的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
一致性哈希算法演示.rar
12-04
一致性哈希算法是一种分布式哈希表（DHT）中用于解决数据分片和负载均衡问题的算法。在大型分布式系统中，例如缓存系统、分布式数据库等，一致性哈希能够确保当节点加入或离开时，尽可能少的数据需要迁移，从而保持...
基于一致性哈希算法的分布式数据库高效扩展方法研究.pdf
08-08
【摘要】中的“高效扩展”和“分布式数据库”是本文的核心话题，研究的是如何利用一致性哈希算法在大数据时代高效地扩展分布式数据库。一致性哈希算法最初由Karger等人提出，目的是解决分布式缓存的问题，它弥补了...
一致性哈希算法C版实现
11-22
一致性哈希算法是一种在分布式系统中解决数据分片和负载均衡问题的算法，它主要解决了在动态添加或移除节点时，尽可能少地改变已经存在的数据分布。在云计算和大数据处理领域，一致性哈希被广泛应用，例如在分布式...
java导出excel设置表头
热门推荐
yangyz_love的专栏
08-01 3万+
import java.sql.SQLException; import java.util.List;   import javax.servlet.http.HttpServletRequest;   import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCel
Dubbo的四种负载均衡方式
HIP的博客
12-22 1万+
DUBBO用到的四种负载均衡算法分析： LoadBalance @SPI(RandomLoadBalance.NAME) public interface LoadBalance { /** * select one invoker in list. *select方法作用是从invokers选出下一个被调用的invoker * @param in...
深入一致性哈希(Consistent Hashing)算法原理，并附100行代码实现
weixin_34344677的博客
01-20 380
2019独角兽企业重金招聘Python工程师标准>>> ...
理解一致性哈希算法的原理
Zach的博客
08-20 801
1. 什么是一致性哈希 一致性哈希算法核心思想,就是通过构造一个长度为2^32的整数环,这个环也被称为一致性Hash环(只是逻辑上的环),将缓存服务器的节点名称的哈希值均匀的分布在[0,2^32-1]的Hash环上,然后根据需要缓存的Key值计算得到其Hash值,然后在Hash环上顺时针查找距离Key的Hash值最近的服务器节点,完成Key到服务器的映射查找;如下图所示 2. 一致性哈希解决了什么问题 Hash算法解决的是集群管理中请求访问的路由的问题,一般是根据一个请求的某个key值取余,路由到
一共有n张大饼分给k个人，分发的时候尽量平均分配，请你求出得到最大数量 与 得到最小数量 的差值。
最新发布
07-12
这个问题可以使用整除和取余运算来解决。首先，我们可以计算出每个人至少可以分到的大饼数量，即 n 除以 k 的整数部分。然后，将剩余的大饼数量（n 除以 k 的余数）依次分配给前面的人，直到没有剩余的大饼。这样，得到最大数量的人将会比得到最小数量的人多一个大饼。 具体地，最大数量为 n 除以 k 的整数部分加一，最小数量为 n 除以 k 的整数部分。它们的差值为 1。 换句话说，无论 n 和 k 的值如何，最大数量和最小数量的差值始终为 1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值