一致性Hash算法(转载)
原文地址http://blog.csdn.net/caigen1988/article/details/7708806
consistent hashing 算法早在 1997 年就在论文 Consistent hashing and random trees 中被提出,目前在 cache 系统中应用越来越广泛;
比如你有 N 个 cache 服务器(后面简称 cache ),那么如何将一个对象 object 映射到 N 个 cache 上呢,你很可能会采用类似下面的通用方法计算 object 的 hash 值,然后均匀的映射到到 N 个 cache ;
hash(object)%N
一切都运行正常,再考虑如下的两种情况;
1 一个 cache 服务器 m down 掉了(在实际应用中必须要考虑这种情况),这样所有映射到 cache m 的对象都会失效,怎么办,需要把 cache m 从 cache 中移除,这时候 cache 是 N-1 台,映射公式变成了 hash(object)%(N-1) ;
2 由于访问加重,需要添加 cache ,这时候 cache 是 N+1 台,映射公式变成了 hash(object)%(N+1) ;
1 和 2 意味着什么?这意味着突然之间几乎所有的 cache 都失效了。对于服务器而言,这是一场灾难,洪水般的访问都会直接冲向后台服务器;
再来考虑第三个问题,由于硬件能力越来越强,你可能想让后面添加的节点多做点活,显然上面的 hash 算法也做不到。
有什么方法可以改变这个状况呢,这就是 consistent hashing...
Hash 算法的一个衡量指标是单调性( Monotonicity ),定义如下:
单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中,又有新的缓冲加入到系统中。哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲中去,而不会被映射到旧的缓冲集合中的其他缓冲区。
容易看到,上面的简单 hash 算法 hash(object)%N 难以满足单调性要求。
consistent hashing 是一种 hash 算法,简单的说,在移除 / 添加一个 cache 时,它能够尽可能小的改变已存在 key 映射关系,尽可能的满足单调性的要求。
下面就来按照 5 个步骤简单讲讲 consistent hashing 算法的基本原理。
考虑通常的 hash 算法都是将 value 映射到一个 32 为的 key 值,也即是 0~2^32-1 次方的数值空间;我们可以将这个空间想象成一个首( 0 )尾( 2^32-1 )相接的圆环,如下面图 1 所示的那样。
图 1 环形 hash 空间
接下来考虑 4 个对象 object1~object4 ,通过 hash 函数计算出的 hash 值 key 在环上的分布如图 2 所示。
hash(object1) = key1;
… …
hash(object4) = key4;
图 2 4 个对象的 key 值分布
Consistent hashing 的基本思想就是将对象和 cache 都映射到同一个 hash 数值空间中,并且使用相同的hash 算法。
假设当前有 A,B 和 C 共 3 台 cache ,那么其映射结果将如图 3 所示,他们在 hash 空间中,以对应的 hash值排列。
hash(cache A) = key A;
… …
hash(cache C) = key C;
图 3 cache 和对象的 key 值分布
说到这里,顺便提一下 cache 的 hash 计算,一般的方法可以使用 cache 机器的 IP 地址或者机器名作为hash 输入。
现在 cache 和对象都已经通过同一个 hash 算法映射到 hash 数值空间中了,接下来要考虑的就是如何将对象映射到 cache 上面了。
在这个环形空间中,如果沿着顺时针方向从对象的 key 值出发,直到遇见一个 cache ,那么就将该对象存储在这个 cache 上,因为对象和 cache 的 hash 值是固定的,因此这个 cache 必然是唯一和确定的。这样不就找到了对象和 cache 的映射方法了吗?!
依然继续上面的例子(参见图 3 ),那么根据上面的方法,对象 object1 将被存储到 cache A 上; object2和 object3 对应到 cache C ; object4 对应到 cache B ;
前面讲过,通过 hash 然后求余的方法带来的最大问题就在于不能满足单调性,当 cache 有所变动时,cache 会失效,进而对后台服务器造成巨大的冲击,现在就来分析分析 consistent hashing 算法。
3.5.1 移除 cache
考虑假设 cache B 挂掉了,根据上面讲到的映射方法,这时受影响的将仅是那些沿 cache B 逆时针遍历直到下一个 cache ( cache A )(原文笔误写为cacheC)之间的对象,也即是本来映射到 cache B 上的那些对象。
因此这里仅需要变动对象 object4 ,将其重新映射到 cache C 上即可;参见图 4 。
图 4 Cache B 被移除后的 cache 映射
3.5.2 添加 cache
再考虑添加一台新的 cache D 的情况,假设在这个环形 hash 空间中, cache D 被映射在对象 object2 和object3 之间。这时受影响的将仅是那些沿 cache D 逆时针遍历直到下一个 cache ( cache B )之间的对象(它们是也本来映射到 cache C 上对象的一部分),将这些对象重新映射到 cache D 上即可。
因此这里仅需要变动对象 object2 ,将其重新映射到 cache D 上;参见图 5 。
图 5 添加 cache D 后的映射关系
考量 Hash 算法的另一个指标是平衡性 (Balance) ,定义如下:
平衡性
平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去,这样可以使得所有的缓冲空间都得到利用。
hash 算法并不是保证绝对的平衡,如果 cache 较少的话,对象并不能被均匀的映射到 cache 上,比如在上面的例子中,仅部署 cache A 和 cache C 的情况下,在 4 个对象中, cache A 仅存储了 object1 ,而 cache C 则存储了 object2 、 object3 和 object4 ;分布是很不均衡的。
为了解决这种情况, consistent hashing 引入了"虚拟节点"的概念,它可以如下定义:
"虚拟节点"( virtual node )是实际节点在 hash 空间的复制品( replica ),一实际个节点对应了若干个"虚拟节点",这个对应个数也成为"复制个数","虚拟节点"在 hash 空间中以 hash 值排列。
仍以仅部署 cache A 和 cache C 的情况为例,在图 4 中我们已经看到, cache 分布并不均匀。现在我们引入虚拟节点,并设置"复制个数"为 2 ,这就意味着一共会存在 4 个"虚拟节点", cache A1, cache A2 代表了 cache A ; cache C1, cache C2 代表了 cache C ;假设一种比较理想的情况,参见图 6 。
图 6 引入"虚拟节点"后的映射关系
此时,对象到"虚拟节点"的映射关系为:
objec1->cache A2 ; objec2->cache A1 ; objec3->cache C1 ; objec4->cache C2 ;
因此对象 object1 和 object2 都被映射到了 cache A 上,而 object3 和 object4 映射到了 cache C 上;平衡性有了很大提高。
引入"虚拟节点"后,映射关系就从 { 对象 -> 节点 } 转换到了 { 对象 -> 虚拟节点 } 。查询物体所在 cache时的映射关系如图 7 所示。
图 7 查询对象所在 cache
"虚拟节点"的 hash 计算可以采用对应节点的 IP 地址加数字后缀的方式。例如假设 cache A 的 IP 地址为202.168.14.241 。
引入"虚拟节点"前,计算 cache A 的 hash 值:
Hash("202.168.14.241");
引入"虚拟节点"后,计算"虚拟节"点 cache A1 和 cache A2 的 hash 值:
Hash("202.168.14.241#1"); // cache A1
Hash("202.168.14.241#2"); // cache A2
问题:1.请问虚拟节点,怎么保证均匀分布在,那个环上呢?
这就要由hash算法来保证了,均匀分布是概率上的均匀,当虚拟节点足够时,就能保证大概均匀了。
2.假如cache通过hash函数计算出的值和 object通过hash函数计算出来的值是同一个hash值怎么办?
那object应该指向哪个cache?
C++实现方法:转自:http://www.cnblogs.com/coser/archive/2011/11/27/2265134.html
一致性hash算法实现有两个关键问题需要解决,一个是用于结点存储和查找的数据结构的选择,另一个是结点hash算法的选择。
首先来谈一下一致性hash算法中用于存储结点的数据结构。通过了解一致性hash的原理,我们知道结点可以想象为是存储在一个环形的数据结构上(如下图),结点A、B、C、D按hash值在环形分布上是有序的,也就是说结点可以按hash值存储在一个有序的队列里。如下图所示,当一个hash值为-2^20的请求点P查找路由结点时,一致性hash算法会按hash值的顺时针方向路由到第一个结点上(B),也就是相当于要在存储结点的有序结构中,按查询的key值找到大于key值中的最小的那个结点。因此,我们应该选择一种数据结构,它应该高效地支持结点频繁地增删,也必须具有理想的查询效率。那么,红黑树可以满足这些要求。红黑树是一颗近似平衡的一颗二叉查找树,因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例,这个在高度上的理论上限允许红黑树在最坏情况下都是高效的,而不同于普通的二叉查找树。 因此,我们选择使用红黑树作为结点的存储结构,除了需要实现红黑树基本的插入、删除、查找的基本功能,我们还应该增加另一个查询lookup函数,用于查找大于key中最小的结点。
字节的字符数组,再对该数组进行处理,得到一个整形的hash值。由于MD5具有高度的离散性,所以生成的hash值也会具有很大的离散性,会均衡的散列到"环"上。
笔者用C++语言对一致性hash算法进行了实现,下面我将会描述下一些关键细节。
、首先定义实体结点类、虚拟结点类。一个实体结点对应多个虚拟结点。
实体结点 CNode_s:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
/*实体结点*/ class CNode_s { public: /*构造函数*/ CNode_s(); CNode_s(char * pIden , int pVNodeCount , void * pData); /*获取结点标示*/ const char * getIden(); /*获取实体结点的虚拟结点数量*/ int getVNodeCount(); /*设置实体结点数据值*/ void setData(void * data); /*获取实体结点数据值*/ void * getData(); private: void setCNode_s(char * pIden, int pVNodeCount , void * pData); char iden[100];/*结点标示串*/ int vNodeCount;/*虚拟结点数目*/ void * data;/*数据结点*/ }; |
虚拟结点 CVirtualNode_s:虚拟结点有一指针指向实体结点
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/*虚拟结点*/ class CVirtualNode_s { public: /*构造函数*/ CVirtualNode_s(); CVirtualNode_s(CNode_s * pNode); /*设置虚拟结点所指向的实体结点*/ void setNode_s(CNode_s * pNode); /*获取虚拟结点所指向的实体结点*/ CNode_s * getNode_s(); /*设置虚拟结点hash值*/ void setHash(long pHash); /*获取虚拟结点hash值*/ long getHash(); private: long hash;/*hash值*/ CNode_s * node; /*虚拟结点所指向的实体结点*/ }; |
、hash算法具有可选择性,定义一个hash算法接口,方便以后进行其他算法的扩展。
这里创建MD5hash类,并继承该接口,通过MD5算法求hash值。
类图:
CHashFun接口:
1 2 3 4 5 6 7 |
/*定义Hash函数类接口,用于计算结点的hash值*/ class CHashFun { public: virtual long getHashVal(const char *) = 0; }; |
CMD5HashFun 类继承CHashFun接口,实现获取hash值的getHashVal函数:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
/*用MD5算法计算结点的hash值,继承CHashFun父类*/ class CMD5HashFun : public CHashFun { public: virtual long getHashVal (const char * ); }; long CMD5HashFun::getHashVal(const char * instr) { int i; long hash = 0; unsignedchar digest[16]; /*调用MD5相关函数,生成instr的MD5码,存入digest*/ md5_state_t md5state; md5_init(&md5state); md5_append(&md5state, (const unsignedchar *)instr,strlen(instr)); md5_finish(&md5state, digest); /* 每四个字节构成一个32位整数, 将四个32位整数相加得到instr的hash值(可能溢出) */ for(i = 0; i < 4; i++) { hash += ((long)(digest[i*4 + 3]&0xFF) << 24) | ((long)(digest[i*4 + 2]&0xFF) << 16) | ((long)(digest[i*4 + 1]&0xFF) << 8) | ((long)(digest[i*4 + 0]&0xFF)); } return hash; } |
、扩展红黑树结构中的查找函数,用于查找红黑树中大于key值中最小的结点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
util_rbtree_node_t* util_rbtree_lookup(util_rbtree_t *rbtree, long key) { if((rbtree != NULL) && !util_rbtree_isempty(rbtree)) { util_rbtree_node_t *node = NULL; util_rbtree_node_t *temp = rbtree->root; util_rbtree_node_t *null = _NULL(rbtree); while(temp != null) { if(key <= temp->key) { node = temp; /* update node */ temp = temp->left; } else if(key > temp->key) { temp = temp->right; } } /* if node==NULL return the minimum node */ return ((node != NULL) ? node : util_rbtree_min(rbtree)); } return NULL; } |
、创建一致性hash类。使其具有插入、删除、查找实体结点的功能。
具体算法和操作过程已经在代码注释中说明。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
class CConHash { public: /*构造函数*/ CConHash(CHashFun * pFunc); /*设置hash函数*/ void setFunc(CHashFun * pFunc); /*增加实体结点 , 0代表成功 , -1代表失败*/ int addNode_s(CNode_s * pNode); /*删除实体结点 , 0代表成功 , -1代表失败*/ int delNode_s(CNode_s * pNode); /*查找实体结点*/ CNode_s * lookupNode_s(const char * object); /*获取一致性hash结构的所有虚拟结点数量*/ int getVNodes(); private: /*Hash函数*/ CHashFun * func; /*虚拟结点总个数*/ int vNodes; /*存储虚拟结点的红黑树*/ util_rbtree_t * vnode_tree; }; /*辅助函数,虚拟结点转化为红黑树结点*/ util_rbtree_node_t * vNode2RBNode(CVirtualNode_s * vnode); CConHash::CConHash(CHashFun * pFunc) { /*设置hash函数*/ assert(pFunc!=NULL); this->func = pFunc; this->vNodes = 0; /*初始化红黑树*/ vnode_tree = new util_rbtree_s(); util_rbtree_init(vnode_tree); } int CConHash::addNode_s(CNode_s * pNode) { if(pNode==NULL)return -1; int vCount = pNode->getVNodeCount(); if(vCount<=0)return -1; CVirtualNode_s * virtualNode ; util_rbtree_node_t * rbNode; char str [100]; char num[10]; strcpy(str,pNode->getIden()); long hash = 0; /*生成虚拟结点并插入到红黑树中*/ for(int i=0;i<vCount;i++) { virtualNode = new CVirtualNode_s(pNode); /*采用str+"i"的方法产生不同的iden串,用于后面的hash值计算*/ itoa(i,num,10); strcat(str,num); hash = func->getHashVal(str); virtualNode->setHash(hash); if(!util_rbtree_search(vnode_tree,hash)) { /*生成红黑树结点*/ rbNode = vNode2RBNode(virtualNode); if(rbNode!=NULL) { /*将该结点插入到红黑树中*/ util_rbtree_insert(vnode_tree,rbNode); this->vNodes++; } } } return 0; } int CConHash::delNode_s(CNode_s * pNode) { if(pNode==NULL)return -1; util_rbtree_node_t * rbNode; char str [100]; char num [10]; strcpy(str,pNode->getIden()); int vCount = pNode->getVNodeCount(); long hash = 0; CVirtualNode_s * node = NULL; /*将该实体结点产生的所有虚拟结点进行删除*/ for(int i=0;i<vCount;i++) { itoa(i,num,10); strcat(str,num);/*采用该方法产生不同的iden串*/ hash = func->getHashVal(str); rbNode = util_rbtree_search(vnode_tree,hash); if(rbNode!=NULL) { node = (CVirtualNode_s *) rbNode->data; if(node->getNode_s()==pNode && node->getHash()==hash) { this->vNodes--; /*将该结点从红黑树中删除*/ util_rbtree_delete(vnode_tree,rbNode); delete rbNode; delete node; } } } return 0; } CNode_s * CConHash::lookupNode_s(const char * object) { if(object==NULL||this->vNodes==0)return NULL; util_rbtree_node_t * rbNode; int key = this->func->getHashVal(object); /*在红黑树中查找key值比key大的最小的结点*/ rbNode = util_rbtree_lookup(vnode_tree,key); if(rbNode!=NULL) { return ((CVirtualNode_s *) rbNode->data)->getNode_s(); } return NULL; } int CConHash::getVNodes() { return this->vNodes; } util_rbtree_node_t * vNode2RBNode(CVirtualNode_s * vnode) { if(vnode==NULL)return NULL; util_rbtree_node_t *rbNode = new util_rbtree_node_t(); rbNode->key = vnode->getHash(); rbNode->data = vnode; return rbNode; } |
写了一个getIP的函数,模拟随机产生的IP字符串。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 |
#include<iostream> #include"CNode_s.h" #include"CVirtualNode_s.h" #include"CHashFun.h" #include"CMD5HashFun.h" #include"CConHash.h" #include<string.h> #include<time.h> using namespace std; void getIP(char * IP) { int a=0, b=0 , c=0 , d=0; a = rand()%256; b = rand()%256; c = rand()%256; d = rand()%256; char aa[4],bb[4],cc[4],dd[4]; itoa(a, aa, 10); itoa(b, bb, 10); itoa(c, cc, 10); itoa(d, dd, 10); strcpy(IP,aa); strcat(IP,"."); strcat(IP,bb); strcat(IP,"."); strcat(IP,cc); strcat(IP,"."); strcat(IP,dd); } int main() { srand(time(0)); freopen("out.txt","r",stdin); /*定义hash函数*/ CHashFun * func = new CMD5HashFun(); /*创建一致性hash对象*/ CConHash * conhash = new CConHash(func); /*定义CNode*/ CNode_s * node1 = new CNode_s("machineA",50,"10.3.0.201"); CNode_s * node2 = new CNode_s("machineB",80,"10.3.0.202"); CNode_s * node3 = new CNode_s("machineC",20,"10.3.0.203"); CNode_s * node4 = new CNode_s("machineD",100,"10.3.0.204"); conhash->addNode_s(node1); conhash->addNode_s(node2); conhash->addNode_s(node3); conhash->addNode_s(node4); /*动态更改结点数据值*/ // node1->setData("99999999"); int ans1 ,ans2 ,ans3 ,ans4; ans1=ans2=ans3=ans4=0; char object[100]; CNode_s * node ; /*动态删除结点*/ //conhash->delNode_s(node2); for(int i =0;i<30;i++) { // getIP(object); // cout<<object<<endl; cin>>object; node = conhash->lookupNode_s(object); if(node!=NULL) { cout<<object<<"----->\t"<<node->getIden()<<" \t "<<(char *)node->getData()<<endl; if(strcmp(node->getIden(),"machineA")==0) ans1++; if(strcmp(node->getIden(),"machineB")==0) ans2++; if(strcmp(node->getIden(),"machineC")==0) ans3++; if(strcmp(node->getIden(),"machineD")==0) ans4++; } } cout<<"Total test cases : "<<ans1+ans2+ans3+ans4<<endl; cout<<"Map to MachineA : "<<ans1<<endl; cout<<"Map to MachineB : "<<ans2<<endl; cout<<"Map to MachineC : "<<ans3<<endl; cout<<"Map to MachineD : "<<ans4<<endl; fclose(stdin); return 0; } |
、删除结点对hash路由的影响测试
测试结果截图:
(Node2)之后的路由情况。不难发现,MachineB down之后,原先的路由请求,较均衡地负载到了其他机器结点,而且对原先路由到其他结点的请求没有影响。比如139.149.184.125这个请求仍会路由到MachineD,并不会因为结点的减少而造成影响。但是,如果是增加实体结点,可能会造成增加前后路由情况不一致的现象,因为路由区间的更加狭小,但是不会有特别大的影响。
另一方面,可以发现实体结点的虚拟结点个数比例分配情况很大程度影响了结点的负载路由情况,比例大致与虚拟结点个数相一致。
总结:
本文首先通过介绍实现一致性hash算法的关键算法和数据结构的选择分析,选择了红黑树作为虚拟结点的存储结构,以及MD5算法作为Hash函数用于计算结点的hash值。并使用C++语言,对一致性hash算法进行了实现,实现了一致性hash实体结点的增加、删除、查找等基本功能,并进行了测试分析。由于笔者水平有限,存在很多有待改进的地方,因此本文仅供大家参考、讨论学习。
项目源代码下载:http://files.cnblogs.com/coser/ConsistentHashAlgorithm.rar
一致性Hash算法(转载)的更多相关文章
- [转载] 一致性hash算法释义
转载自http://www.cnblogs.com/haippy/archive/2011/12/10/2282943.html 一致性Hash算法背景 一致性哈希算法在1997年由麻省理工学院的Ka ...
- 【转载】一致性hash算法释义
http://www.cnblogs.com/haippy/archive/2011/12/10/2282943.html 一致性Hash算法背景 一致性哈希算法在1997年由麻省理工学院的Karge ...
- 【转载】对一致性Hash算法,Java代码实现的深入研究
原文地址:http://www.cnblogs.com/xrq730/p/5186728.html 一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细 ...
- 一致性hash算法详解
转载请说明出处:http://blog.csdn.net/cywosp/article/details/23397179 一致性哈希算法在1997年由麻省理工学院提出的一种分布式哈希(DHT) ...
- 一致性 hash 算法( consistent hashing )a
一致性 hash 算法( consistent hashing ) 张亮 consistent hashing 算法早在 1997 年就在论文 Consistent hashing and rando ...
- memcache的一致性hash算法使用
一.概述 1.我们的memcache客户端(这里我看的spymemcache的源码),使用了一致性hash算法ketama进行数据存储节点的选择.与常规的hash算法思路不同,只是对我们要存储数据的k ...
- 一致性Hash算法说明
本文章比较好的说明了一致性Hash算法的概念 Hash算法一般分为除模求余和一致性Hash1.除模求余:当新增.删除机器时会导致大量key的移动2.一致性Hash:当新增.删除机器时只会影响到附近的k ...
- 集群扩容的常规解决:一致性hash算法
写这篇博客是因为之前面试的一个问题:如果memcached集群需要增加机器或者减少机器,那么其他机器上的数据怎么办? 最后了解到使用一致性hash算法可以解决,下面一起来学习下吧. 声明与致谢: 本文 ...
- 一致性 hash 算法(转)
add by zhj:介绍了什么是一致性hash,以及实现一致性hash的一种算法. 原文:http://my.oschina.net/u/195065/blog/193614 目录[-] 一致性 h ...
随机推荐
- Xmemcached与SpringBoot实际案例
在本人的这篇文章<Xmemcached集群与SpringBoot整合>基础上,进行XMemcached与SpringBoot实际案例的结合. 有以下这张表,将这张表的增删改查操作都添加到X ...
- nginx 安全配置和限制访问
nginx基本安全配置 配置ssl证书 listen 443 ssl; ssl_certificate /usr/local/nginx/conf/server.crt; ssl_certificat ...
- Java 应用程序的运行机制
计算机高级语言: 编译型 (C) 解释性(JS)Java 使两种类型的结合 java 编译器 class \|/jvm ...
- [转帖]YES!AMD千元无敌U闪亮登场、16核至尊为用户着想
YES!AMD千元无敌U闪亮登场.16核至尊为用户着想 投递人 itwriter 发布于 2019-09-30 09:34 评论(0) 有567人阅读 原文链接 [收藏] « » https://ne ...
- MEAN: AngularJS + NodeJS的REST API开发教程
Node.JS https://www.jdon.com/idea/nodejs/web-app-with-angularjs-and-rest-api-with-node.html Mean是一个热 ...
- golang中switch用法细节
1. switch穿透-fallthrough, 如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透,默认只穿透一层 2. Type Switch: s ...
- PAT(B) 1020 月饼(Java)
题目链接:1020 月饼 (25 point(s)) 分析 将月饼(库存量,总售价,单价)封装成MoonCake类 Scanner会超时,用BufferedReader类读取数据 读取的时候用字符串数 ...
- java——数据类型和运算符
强类型语言 Java语言是一门强类型语言.强类型包含两方面的含义:①所有的变量必须先声明.后使用:②指定类型的变量只能接受类型与之匹配的值.强类型语言可以在编译过程中发现源代码的错误,从而保证程序更加 ...
- 剑指offer(5)——从尾到头打印链表
题目: 输入一个链表的头结点,从尾到头反过来打印出每个结点的值.结点定义如下: public class ListNode { int val; ListNode next = null; ListN ...
- 分布式服务追踪与调用链 Zikpin
分布式服务追踪与调用链系统产生的背景 在为服务中,如果服务与服务之间的依赖关系非常复杂,如果某个服务出现了一些问题,很难追查到原因,特别是服务与服务之间调用的时候. 在微服务系统中,随着业务的发展,系 ...