节点管理源码

‘壹’ 阿里sentinel源码解析

sentinel是阿里巴巴开源的流量整形(限流、熔断)框架，目前在github拥有15k+的star，sentinel以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

我们以sentinel的主流程入手，分析sentinel是怎么搜集流量指标，完成流量整形的。

首先我们先看一个sentinel的简单使用demo，只需要调用SphU.entry获取到entry，然后在完成业务方法之后调用entry.exit即可。

SphU.entry会调用Env.sph.entry，将name和流量流向封装成StringResourceWrapper，然后继续调用entry处理。

进入CtSph的entry方法，最终来到entryWithPriority，调用InternalContextUtil.internalEnter初始化ThreadLocal的物锋Context，然后调用lookProcessChain初始化责任链，最终调用chain.entry进入责任链进行处理。

InternalContextUtil.internalEnter会调用trueEnter方法，主要是生成DefaultNode到contextNameNodeMap，然后生成Context设置到contextHolder的过程。

lookProcessChain已经做过优化，支持spi加载自定义的责任链bulider，如果没有定义则使用默认的DefaultSlotChainBuilder进行加载。默认加载的slot和顺序可见镇楼图，不再细说。

最后来到重头戏chain.entry进入责任链进行处理，下面会按照顺序分别对每个处理器进行分析。
首先来到NodeSelectorSlot，主要是获取到name对应的DefaultNode并缓存起来，设置为context的当前节点，然后通知下一个节点。

下一个节点是ClusterBuilderSlot，继续对DefaultNode设置ClusterNode与OriginNode，然颂咐后通知下一节点。

下一个节点是LogSlot，只是单纯的打印日志，不再细说。

下一个节点是StatisticSlot，是一个后置节点，先通知下一个节点处理完后，
1.如果没有报错，则对node、clusterNode、originNode、ENTRY_NODE的线程数、通过请求数进行增加。
2.如果报错是PriorityWaitException，则只对线程数进行增加。
3.如果报错是BlockException，设置报错到node，然后对阻挡请求数进行增加。
4.如果是其他报错，设置报错到node即可。

下一个节点是FlowSlot，这个节点就是重要的限流处理节点，进入此节点是调用checker.checkFlow进行限流处理。

来到FlowRuleChecker的checkFlow方法，调用ruleProvider.apply获取到资源对应的FlowRule列表，然后遍历FlowRule调用canPassCheck校验限流规则。

canPassCheck会根据rule的限流模式，选择集群限流或者本地限流，这里分别作出分析。

passLocalCheck是本地限流的入口，首先会调用选出限流的node，然后调用canPass进行校验。罩樱晌

会根据以下规则选中node。
1.strategy是STRATEGY_DIRECT。
1.1.limitApp不是other和default，并且等于orgin时，选择originNode。
1.2.limitApp是other，选择originNode。
1.3.limitApp是default，选择clusterNode。
2.strategy是STRATEGY_RELATE，选择clusterNode。
3.strategy是STRATEGY_CHAIN，选择node。

选择好对应的node后就是调用canPass校验限流规则，目前sentinel有三种本地限流规则：普通限流、匀速限流、冷启动限流。

普通限流的实现是DefaultController，就是统计当前的线程数或者qps加上需要通过的数量有没有大于限定值，小于等于则直接通过，否则阻挡。

匀速限流的实现是RateLimiterController，使用了AtomicLong保证了latestPassedTime的原子增长，因此停顿的时间是根据latestPassedTime-currentTime计算出来，得到一个匀速的睡眠时间。

冷启动限流的实现是WarmUpController，是sentinel中最难懂的限流方式，其实不太需要关注这些复杂公式的计算，也可以得出冷启动的限流思路：
1.当qps已经达到温热状态时，按照正常的添加令牌消耗令牌即可。
2.当qps处于过冷状态时，会添加令牌使得算法继续降温。
3.当qps逐渐回升，大于过冷的边界qps值时，不再添加令牌，慢慢消耗令牌使得逐渐增大单位时间可通过的请求数，让算法继续回温。
总结出一点，可通过的请求数跟令牌桶剩余令牌数量成反比，以达到冷启动的作用。

接下来是集群限流，passClusterCheck是集群限流的入口，会根据flowId调用clusterSerivce获取指定数量的token，然后根据其结果判断是否通过、睡眠、降级到本地限流、阻挡。

接下来看一下ClusterService的处理，会根据ruleId获取到对应的FlowRule，然后调用ClusterFlowChecker.acquireClusterToken获取结果返回。ClusterFlowChecker.acquireClusterToken的处理方式跟普通限流是一样的，只是会将集群的请求都集中在一个service中处理，来达到集群限流的效果，不再细说。

FlowSlot的下一个节点是DegradeSlot，是熔断处理器，进入时会调用performChecking，进而获取到CircuitBreaker列表，然后调用其tryPass校验是否熔断。

来到AbstractCircuitBreaker的tryPass方法，主要是判断熔断器状态，如果是close直接放行，如果是open则会校验是否到达开启halfopen的时间，如果成功将状态cas成halfopen则继续放行，其他情况都是阻拦。

那怎么将熔断器的状态从close变成open呢？怎么将halfopen变成close或者open呢？sentinel由两种熔断器：错误数熔断器ExceptionCircuitBreaker、响应时间熔断器ResponseTimeCircuitBreaker，都分析一遍。
当业务方法报错时会调用Tracer.traceEntry将报错设置到entry上。

当调用entry.exit时，会随着责任链来到DegradeSlot的exit方法，会遍历熔断器列表调用其onRequestComplete方法。

ExceptionCircuitBreaker的onRequestComplete会记录错误数和总请求数，然后调用继续处理。
1.当前状态是open时，不应该由熔断器底层去转换状态，直接退出。
2.当前状态是halfopen时，如果没有报错，则将halfopen变成close，否则将halfopen变成open。
3.当前状态时close时，则根据是否总请求达到了最低请求数，如果达到了话再比较错误数/错误比例是否大于限定值，如果大于则直接转换成open。

ExceptionCircuitBreaker的onRequestComplete会记录慢响应数和总请求数，然后调用继续处理。
1.当前状态是open时，不应该由熔断器底层去转换状态，直接退出。
2.当前状态是halfopen时，如果当前响应时间小于限定值，则将halfopen变成close，否则将halfopen变成open。
3.当前状态时close时，则根据是否总请求达到了最低请求数，如果达到了话再比较慢请求数/慢请求比例是否大于限定值，如果大于则直接转换成open。

下一个节点是AuthoritySlot，权限控制器，这个控制器就是看当前origin是否被允许进入请求，不允许则报错，不再细说。

终于来到最后一个节点SystemSlot了，此节点是自适应处理器，主要是根据系统自身负载（qps、最大线程数、最高响应时间、cpu使用率、系统bbr）来判断请求是否能够通过，保证系统处于一个能稳定处理请求的安全状态。

尤其值得一提的是bbr算法，作者参考了tcp bbr的设计，通过最大的qps和最小的响应时间动态计算出可进入的线程数，而不是一个粗暴的固定可进入的线程数，为什么能通过这两个值就能计算出可进入的线程数？可以网上搜索一下tcp bbr算法的解析，十分巧妙，不再细说。

‘贰’ 以太坊源码分析--p2p节点发现

节点发现功能主要涉及 Server Table udp 这几个数据结构，它们有独自的事件响应循环，节点发现功能便是它们互相协作完成的。其中，每个以太坊客户端启动后都会在本地运行一个 Server ，并将网络拓扑中相邻的节点视为 Node ，而 Table 是 Node 的容器， udp 则是负责维持底层的连接。下面重点描述它们中重要的字段和事件循环处理的关键部分。

PrivateKey - 本节点的私钥，用于与其他节点建立时的握手协商
Protocols - 支持的所有上层协议
StaticNodes - 预设的静态 Peer ，节点启动时会首先去向它们发起连接，建立邻居关系
newTransport - 下层传输层实现，定义握手过程中的数据加密解密方式，默认的传输层实现是用 newRLPX() 创建的 rlpx ，这不是本文的重点
ntab - 典型实现是 Table ，所有 peer 以 Node 的形式存放在 Table
ourHandshake - 与其他节点建立连接时的握手信息，包含本地节点的版本号以及支持的上层协议
addpeer － 连接握手完成后，连接过程通过这个通道通知 Server

Server 的监听循环，启动底层监听socket，当收到连接请求时，Accept后调用 setupConn() 开始连接建立过程

Server的主要事件处理和功能实现循环

Node 唯一表示网络上的一个节点

IP - IP地址
UDP/TCP - 连接使用的UDP/TCP端口号
ID - 以太坊网络中唯一标识一个节点，本质上是一个椭圆曲线公钥(PublicKey)，与 Server 的 PrivateKey 对应。一个节点的IP地址不一定是固定的，但ID是唯一的。
sha - 用于节点间的距离计算

Table 主要用来管理与本节点与其他节点的连接的建立更新删除

bucket - 所有 peer 按与本节点的距离远近放在不同的桶(bucket)中，详见之后的 节点维护
refreshReq - 更新 Table 请求通道

Table 的主要事件循环，主要负责控制 refresh 和 revalidate 过程。
refresh.C - 定时(30s)启动Peer刷新过程的定时器
refreshReq - 接收其他线程投递到 Table 的 刷新Peer连接 的通知，当收到该通知时启动更新，详见之后的 更新邻居关系
revalidate.C - 定时重新检查以连接节点的有效性的定时器，详见之后的 探活检测

udp 负责节点间通信的底层消息控制，是 Table 运行的 Kademlia 协议的底层组件

conn - 底层监听端口的连接
addpending － udp 用来接收 pending 的channel。使用场景为：当我们向其他节点发送数据包后(packet)后可能会期待收到它的回复，pending用来记录一次这种还没有到来的回复。举个例子，当我们发送ping包时，总是期待对方回复pong包。这时就可以将构造一个pending结构，其中包含期待接收的pong包的信息以及对应的callback函数，将这个pengding投递到udp的这个channel。 udp 在收到匹配的pong后，执行预设的callback。
gotreply - udp 用来接收其他节点回复的通道，配合上面的addpending，收到回复后，遍历已有的pending链表，看是否有匹配的pending。
Table - 和 Server 中的ntab是同一个 Table

udp 的处理循环，负责控制消息的向上递交和收发控制

udp 的底层接受数据包循环，负责接收其他节点的 packet

以太坊使用 Kademlia 分布式路由存储协议来进行网络拓扑维护，了解该协议建议先阅读 易懂分布式 。更权威的资料可以查看 wiki 。总的来说该协议：

源码中由 Table 结构保存所有 bucket ， bucket 结构如下

节点可以在 entries 和 replacements 互相转化，一个 entries 节点如果 Validate 失败，那么它会被原本将一个原本在 replacements 数组的节点替换。

有效性检测就是利用 ping 消息进行探活操作。 Table.loop() 启动了一个定时器（0~10s），定期随机选择一个bucket，向其 entries 中末尾的节点发送 ping 消息，如果对方回应了 pong ，则探活成功。

Table.loop() 会定期（定时器超时）或不定期（收到refreshReq）地进行更新邻居关系（发现新邻居），两者都调用 doRefresh() 方法，该方法对在网络上查找离自身和三个随机节点最近的若干个节点。

Table 的 lookup() 方法用来实现节点查找目标节点，它的实现就是 Kademlia 协议，通过节点间的接力，一步一步接近目标。

当一个节点启动后，它会首先向配置的静态节点发起连接，发起连接的过程称为 Dial ，源码中通过创建 dialTask 跟踪这个过程

dialTask表示一次向其他节点主动发起连接的任务

在 Server 启动时，会调用 newDialState() 根据预配置的 StaticNodes 初始化一批 dialTask ， 并在 Server.run() 方法中，启动这些这些任务。

Dial 过程需要知道目标节点( dest )的IP地址，如果不知道的话，就要先使用 recolve() 解析出目标的IP地址，怎么解析？就是先要用借助 Kademlia 协议在网络中查找目标节点。

当得到目标节点的IP后，下一步便是建立连接，这是通过 dialTask.dial() 建立连接

连接建立的握手过程分为两个阶段，在在 SetupConn() 中实现
第一阶段为 ECDH密钥建立 ：

第二阶段为协议握手,互相交换支持的上层协议

如果两次握手都通过，dialTask将向 Server 的 addpeer 通道发送 peer 的信息

‘叁’ linux内核源码解析-list.h

开头就说明了这里的 list.h 文件来自 Linux Kernel （ */include/linux/list.h ），只是去除了列表项的硬件预加载部分。

进行宏替换后就是

Note: 没搞懂这里为什么加个 osn 前缀，原本是 list_add ，现在是 osn_list_add 。

可以看到就是个简单的链表节点删除过程，同时把删除节点的前后指针设为无法访问。

删除节点后初始化，前后指针都指向自己

从A链表删除后头插法插入B链表

从A链表删除后尾插法插入B链表

先对 list 判空，非空就把 list 链表除头节点外裁剪到 head 头节点在的链表中。函数不安全， list 节点可以继续访问其他节点。

多了一步 list 重新初始化的过程。

(unsigned long)(&((type *)0)->member))) 将0x0地址强制转换为 type * 类型，然后取 type 中的成员 member 地址，因为起始地址为0，得到的 member 的地址就直接是该成员相对于 type 对象的偏移地址了。
所以该语句的功能是：得到 type 类型对象中 member 成员的地址偏移量。
先将 ptr 强制转换为 char * 类型（因为 char * 类型进行加减的话，加减量为 sizeof(char)*offset ， char 占一个字节空间，这样指针加减的步长就是1个字节，实现加一减一。）
整句话的意思就是：得到指向 type 的指针，已知成员的地址，然后减去这个成员相对于整个结构对象的地址偏移量，得到这个数据对象的地址。

就是从前往后，从后往前的区别

Note: 从head节点开始（不包括head节点！）遍历它的每一个节点！它用n先将下一个要遍历的节点保存起来，防止删除本节点后，无法找到下一个节点，而出现错误！

已知指向某个结构体的指针pos，以及指向它中member成员的指针head，从下一个结构体开始向后遍历这个结构体链

Note: 同理，先保存下一个要遍历的节点！从head下一个节点向后遍历链表。

list.h使用说明
linux内核list.h分析(一)
linux内核list.h分析(二)
【Linux内核数据结构】最为经典的链表list

‘肆’ java swing左边树图，当点击任意节点时，右边显示显示数据， 求一个简单的源码例子

importjava.awt.BorderLayout;
importjava.awt.Container;
importjava.awt.Dimension;

importjavax.swing.JFrame;
importjavax.swing.JLabel;
importjavax.swing.JPanel;
importjavax.swing.JTree;
importjavax.swing.event.TreeSelectionEvent;
importjavax.swing.event.TreeSelectionListener;
importjavax.swing.tree.DefaultMutableTreeNode;

{
	privateJPanelp;
	
	publicTestSwingTree(Stringtitle){
		super(title);
	}
	publicvoidinit(){
		Containerc=this.getContentPane();
		
		DefaultMutableTreeNoderoot=newDefaultMutableTreeNode("root");
		DefaultMutableTreeNodechild1=newDefaultMutableTreeNode("child1");
		DefaultMutableTreeNodechild11=newDefaultMutableTreeNode("child11");
		DefaultMutableTreeNodechild12=newDefaultMutableTreeNode("child12");
		DefaultMutableTreeNodechild2=newDefaultMutableTreeNode("child2");
		DefaultMutableTreeNodechild3=newDefaultMutableTreeNode("child3");
		DefaultMutableTreeNodechild31=newDefaultMutableTreeNode("child31");
		root.add(child1);
		root.add(child2);
		root.add(child3);
		child1.add(child11);
		child1.add(child12);
		child3.add(child31);
		JTreetree=newJTree(root);
		tree.setPreferredSize(newDimension(120,400));
		tree.addTreeSelectionListener(newTreeSelectionListener(){
			
			publicvoidvalueChanged(TreeSelectionEvente){
				p.removeAll();
				JLabell=newJLabel(e.getPath().toString());
				l.setBounds(5,190,170,20);
				p.add(l);
				p.repaint();
			}
		});
		c.add(tree,BorderLayout.WEST);
		
		p=newJPanel();
		p.setLayout(null);
		p.setPreferredSize(newDimension(180,400));
		c.add(p,BorderLayout.CENTER);
		this.setLocation(400,300);
		this.setSize(300,400);
		this.setResizable(false);
		this.setVisible(true);
		this.setDefaultCloseOperation(this.DISPOSE_ON_CLOSE);
	}
	publicstaticvoidmain(String[]args){
		newTestSwingTree("TestSwingJtree").init();
	}
}