集群源码
㈠ springcloud2021版微服务集群
1、springcloud nacos gateway openfign Resilience4J 测试网关熔断，feign重试机制，服务的熔断机制，实例的feign熔断机制
2、springcloud 体系弯神监控，基于 actuator prometheus grafana
3、springcloudStreamRocketmq事件驱动机制测试 延迟队列，死信队列
4、接口文档采用springdoc来编写，将其中敏搭的枚举等自定义序列化风格
5、es集群测试
具体源码地址桥闹拿： https://github.com/coralloc8/coral-cloud/tree/master/cloud-test
㈡ Zookeeper之两阶段提交源码分析
zookeeper集群为了保证数据一致性，使用了两阶段提交。
在zookeeper集群的角色有：leader、follower、observer。
在这几个角色中处理读写请求是不同的：
读请求：从当前节点直接读取数据
写请求：在leader直接进行两阶段提交、在非leader则是把请求转交给leader处理
所以，分析两阶段提交就是分析集群模式下的请求处理。在单机模式在请求处理是经过RequestProcessor请求处理链处理。
单个zookeeprt请求处理主要有以下几步：
1、对当前请求生成日志txn
2、持久化日志txn
3、根据日志txn更新Database
两阶段提交（2PC）步骤：
其中标绿色的PrepRequestProcessor、SyncRequestProcessor、CommitProcessor都继承了ZooKeeperCriticalThread是一个线程。
org.apache.zookeeper.server.quorum.LeaderZooKeeperServer#setupRequestProcessors
org.apache.zookeeper.server.quorum.ProposalRequestProcessor#ProposalRequestProcessor
org.apache.zookeeper.server.quorum.LeaderRequestProcessor#processRequest
①、检查是不是local session本地session，创建临时节点会升级session
org.apache.zookeeper.server.quorum.QuorumZooKeeperServer#checkUpgradeSession
②、交给下一个请求处理器处理
作用与单机模式相同，给请求Request的Hdr和Txn赋值，然后交给下一个请求处理器处理
如果是写请求(request.getHdr() != null)，则会把当前请求封装为协议并发送给follower。发送之后交给SyncRequestProcessor持久化处理
org.apache.zookeeper.server.quorum.Leader#propose
org.apache.zookeeper.server.quorum.Leader#sendPacket
发送到所有其他Followe节点forwardingFollowers
把请求放入到queuedRequests阻塞队列
①、对请求进行持久化与单机相同
org.apache.zookeeper.server.SyncRequestProcessor#run
向lead发送自己的ack（2PC发送ACK）
org.apache.zookeeper.server.quorum.Leader#processAck
org.apache.zookeeper.server.quorum.Leader#tryToCommit
org.apache.zookeeper.server.quorum.CommitProcessor#commit
提交当前请求，放入到committedRequests，最终会更新database
CommitProcessor类参数：
queuedRequests：表示接收到的请求，没有进行两阶段的提交
queuedWriteRequests：表示接收到的写请求，没有进行两阶段的提交
committedRequests：表示可以提交的请求，在两阶段验证过半之后进行会在本地进行committe操作，便添加到这个队列
commitIsWaiting：表示存在可以提交的请求（committedRequests是否有值，有true）
pendingRequests：是一个map集合，表示每个客户端sessionId的请求
Leader类参数：
outstandingProposals：表示记录提议的请求的队列，符合过半机制之后会移除
toBeApplied：表示记录待生效的请求，在FinalRequestProcessor移除
①、processRequest
org.apache.zookeeper.server.quorum.CommitProcessor#processRequest
首先判断是否需要两阶段提交。如果需要则会添加到queuedWriteRequests队列
org.apache.zookeeper.server.quorum.CommitProcessor#needCommit
如果是更改操作则返回true
d、然后，再看一下这个while的退出条件。
①、从queuedRequests取出的是空
②、如果queuedRequests数据不为空，那么requestsToProcess是大于0的。这时只有maxReadBatchSize < 0或readsProcessed <= maxReadBatchSize才能退出。
maxReadBatchSize < 0表示默认是-1，如果配置了这个参数当连续读了readsProcessed时，也会退出。
③、pendingRequests和committedRequests不为空
e、commitIsWaiting有待提交的
org.apache.zookeeper.server.quorum.Leader.ToBeAppliedRequestProcessor#processRequest
删除toBeApplied
其中标绿色的FollowerRequestProcessor、CommitProcessor、SyncRequestProcessor都继承了ZooKeeperCriticalThread是一个线程。
org.apache.zookeeper.server.quorum.FollowerZooKeeperServer#setupRequestProcessors
开了两条链：
FollowerRequestProcessor(firstProcessor)---->CommitProcessor----->FinalRequestProcessor
SyncRequestProcessor---->SendAckRequestProcessor
org.apache.zookeeper.server.quorum.FollowerRequestProcessor#processRequest
请求添加到queuedRequests队列
FollowerRequestProcessor是一个线程，会从queuedRequests获取请求
org.apache.zookeeper.server.quorum.FollowerRequestProcessor#run
createSession和closeSession也会转发给lead节点处理
org.apache.zookeeper.server.quorum.SendAckRequestProcessor#processRequest
在用SendAckRequestProcessor处理之前会先调用SyncRequestProcessor进行持久化处理，由于与单机或lead处理相同就不单独列出来了。
向领导者发送确认ack包
org.apache.zookeeper.server.quorum.Learner#writePacket
在经过FollowerRequestProcessor处理后，lead端会得到一个Request的请求
org.apache.zookeeper.server.quorum.LearnerHandler#run
org.apache.zookeeper.server.quorum.Leader#submitLearnerRequest
在连接Follower节点的客户端发送更改命令请求会转发到leader节点的prepRequestProcessor进行处理
1、run
org.apache.zookeeper.server.quorum.QuorumPeer#run
2、followLeader
org.apache.zookeeper.server.quorum.Follower#followLeader
不断读取从lead端的数据包
org.apache.zookeeper.server.quorum.FollowerZooKeeperServer#logRequest
其中标绿色的ObserverRequestProcessor、CommitProcessor、SyncRequestProcessor都继承了ZooKeeperCriticalThread是一个线程。
org.apache.zookeeper.server.quorum.ObserverZooKeeperServer#setupRequestProcessors
也是开了两条链：
ObserverRequestProcessor(firstProcessor)---->CommitProcessor----->FinalRequestProcessor
SyncRequestProcessor---->null
observer节点不参与两阶段提交，所以同步SyncRequestProcessor之后没有ACK确认提交。这样既提高了读效率，又对写效率没有影响。请求处理链与leader、follower的功能相同不再累述。
zookeeper集群的两阶段提交，是在写操作的情况下发生的。2PC的整体实现逻辑是在RequestProcessor请求处理链处理的。只有在接受到的ACK超过一半才会进行提交，提交的实现逻辑是在CommitProcessor中实现的，CommitProcessor处理器中里面涉及多种集合、队列等参数(需要首先了解这些参数意义，然后再读CommitProcessor源码)。
㈢ 14. bbo源码-集群容错之MergeableCluster
在bbo官方的用户手册中，提到了使用 MergeableCluster 的场景--分组聚合：
功能示意图如下：
定义菜单接口方式：
Provider暴露服务--一个服务属于 group-hot ，一个服务属于 group-cold ：
笔者测试时启动了两个Provider，所以总计有四个服务，bbo-monitor监控显示如下：
Consumer调用服务：
几个重要的配置说明：
com.alibaba.bbo.rpc.cluster.Merger 文件内容如下：
核心源码在 MergeableClusterInvoker.java 中，源码如下所示：
在条件分支 if ( merger.startsWith(".") ) {} 中，有一段逻辑： method = returnType.getMethod( merger, returnType ); ，即从bbo服务接口方法返回类型即 java.util.List 中查找merger配置的方法，例如 .addAll ，我们先看一下debug过程各变量的值：
bbo源码中 method = returnType.getMethod( merger, returnType ); 调用 Method method = getMethod0(name, parameterTypes, true); ，再调用 Method res = privateGetMethodRecursive(name, parameterTypes, includeStaticMethods, interfaceCandidates); ，最后调用 searchMethods(privateGetDeclaredMethods(true), name, parameterTypes)) ，得到最后方法匹配的核心逻辑如下：
从searchMethods()源码可知，方法匹配需要满足几个条件：
由上面的分析可知，如果要merger=".addAll"能够正常工作，那么只需要将bbo服务的返回类型改成 Collection 即可，例如：
如果 com.alibaba.bbo.rpc.cluster.Merger 文件集中方法无法满足需求，需要自定义实现，那么还是和bbo其他扩展实现一样，依赖SPI。只需要一下几步实现即可：
㈣ redis cluster集群选主
redis数据淘汰原理
redis过期数据删除策略
redis server事件模型
redis cluster mget 引发的讨论
redis 3.x windows 集群搭建
redis 命令执行过程
redis string底层数据结构
redis list底层数据结构
redis hash底层数据结构
redis set底层数据结构
redis zset底层数据结构
redis 客户端管理
redis 主从同步-slave端
redis 主从同步橘拦-master端
redis 主从超时数稿检测
redis aof持久化
redis rdb持久化
redis 数据恢复过程
redis TTL实现原理
redis cluster集群建立
redis cluster集群选主圆毕胡
当slave发现自己的master变为FAIL状态时，便尝试进行Failover，以期成为新的master。由于挂掉的master可能会有多个slave。Failover的过程需要经过类Raft协议的过程在整个集群内达到一致， 其过程如下：
在作为slave角色节点会定期发送ping命令来检测master的存活性，如果检测到master未响应，那么就将master节点标记为疑似下线。
clusterHandleSlaveFailover执行重新选主的核心逻辑。
clusterHandleSlaveFailover内部通过clusterRequestFailoverAuth方法向集群当中的所有节点发送CLUSTERMSG_TYPE_FAILOVER_AUTH_REQUEST报文，通知大家slave准备执行failover。
当节点收到超过n/2+1个master的response后即升级为主。
在redis主从选举过程中报文相关的解析逻辑，clusterProcessPacket内部主要处理CLUSTERMSG_TYPE_FAILOVER_AUTH_REQUEST和CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK报文。
redis cluster集群的源码分析(1)
Redis Cluster 实现细节
㈤ 集群redis哨兵模式连接方式，解决database不生效问题（附源码）
公司里面项目基本都早败谨使用哨兵模式
注意事项：
1 引入pom依赖
2 添加redis哨兵配置，database主动设置，才会生效
3 application.yml配置枯物
4 项目目录
5 启动测试连接
可以看到redis.clients.jedis.JedisSentinelPool : Created JedisSentinelPool to master at 10.10.195.249:6379已经启动了
作为程序员第陆基 140 篇文章，每次写一句歌词记录一下，看看人生有几首歌的时间，wahahaha ...
㈥ zk源码阅读37:ZooKeeperServer源码分析
前面针对server启动到选举leader进行了一个小结，现在进入leader和follower的启动交互过程，需要先讲ZooKeeperServer，
在之前源码阅读的25节里面带过了一部分，这里详细讲解ZooKeeperServer的源码
继承关系如下
本节主要讲解内容如下
在源码阅读第24节讲解了，这里不赘述
是SessionTracker的内部接口
如下图
除去log，jmx相关部分，源码如下
ChangeRecord是ZooKeeperServer的内部类，衫亩下面会介绍
ServerStats,ZooKeeperServerListener都在25节的源码介绍过
这个类或升森并没有调用，不用管
定义异常
这个数据结构为了促进PrepRequestProcessor以及FinalRequestProcessor的信息共享,讲到调用链的时候再讲。
其中，StatPersisted在源码阅读7中讲DataNode的时候讲过了
描述当前server所处的状态
这里列举处两个底层调用的构造函数
启动涉及到db的数据加载，这里也有集群和单机两种，调用顺序为
主要是集群的时候，server选完了leader，由leader才能调用数据加载loadData
下面按照单机版startdata函数展开
初始化zkDb完成数据加载
恢复session和数据，单机版启动或者集群版leader选举之后调用lead方法时，会调用该方法。
主要完成设置zxid以及把无效的session给kill掉的工作
这里注意，为什么需要干这件事情，在下面思考中会说
里面调用了setZxid(不展开)以及killSession函数
清除db中临时会话记录，会话跟踪器也清除记录
入口是ZooKeeperServer#startup，zkServer都是在上述加载了db的数据之后，调用startup来完成启动
启动的入口函数
调用了createSessionTracker等函数，介绍如下
createSessionTracker 完成会话跟踪器的创建
这里是默认的单机版实现，在集群版不同的角色有不同的实现,主要是参数sid不会传1，而是配置中的sid
startSessionTracker 启动会话跟踪器
设置笑薯服务器运行状态，对于ERROR和SHUTDOWN的state，进行对应的操作
在 源码阅读25:服务器异常报警，关闭机制 讲过，这里不赘述
安装请求处理链路,是PrepRequestProcessor -> SyncRequestProcessor -> FinalRequestProcessor顺序
具体在后面请求处理链路再讲
两个函数getServerId和expire
processConnectRequest用于处理client的连接请求，不展开
值得注意的地方是重连的调用
展开如下
重连的核心函数
验证sessionId和传递来的密码的正确性
根据sessionId生成密码
在会话跟踪器SessionTracker中判断会话是否还有小
完成会话初始化，根据参数valid代表认证通过与否，用来判断server是接收连接请求，还是发出closeConn的请求,不展开，重要部分如下
除去的get,set,jmx,shutdown相关函数，剩下重要函数如下
部分函数列举如下
获取下一个server的zxid,调用方需要确保控制并发顺序
上面ZooKeeperServer#expire调用了close函数，介绍如下
该函数用于提交一个 关闭某个sessionId 的请求
这里有两个函数
之前在源码21节 会话管理中讲解了会话清除，在sessionTracker的记录是马上清除的，而DateTree中临时会话的清除是通过调用链一步步来的，也就是说两个步骤不是同步的，所以如果中间服务器状态改变了，会出现不一致的情况
requestsInProcess代表正在处理的请求个数
就是说发出请求时，requestsInProcess+1，最后完成请求时，requestsInProcess-1.涉及到请求处理链。
ZooKeeperServer#checkPasswd调用
ZooKeeperServer#generatePasswd
就是sessionId要和sessionId^superSecret生成的第一个随机数相匹配即可
密码不是client端设置的，是根据sessionId生成的
ZooKeeperServer#processConnectRequest 里面调用reopenSession中
在上面已经讲了,核心就是
这里还没有深入看，先存疑
比如思考中提到的loadData为什么会出现数据不一致，属于某种异常情况的处理
为什么不放到另外一个类里面去
㈦ “官方”总结2021的IPFS:成为Web3主流势头的支柱
原文：
Web3 应用程序在 2021 年的受欢迎程度飙升。该技术用例的增长也为支持它们的基础设施带来了更大的需求。 IPFS 已成为开发人员和用户在新兴 Web3 生态系统中使用的解决方案不可或缺的一部分。 网络统计：存储在 IPFS 上的 NFT：15M+每周唯一活跃 IPFS 节点：230K+ipfs.io 网关用户每周：370 万+ipfs.io 每周网关请求：805M+
2021 年合作与整合
拥有 IPFS 和NFT.Storage等工具 , Web3.存储 , 和Estuary 在后端使项目能够提供分散存储功能作为其产品的一部分。
让我们来看看一些最值得注饥腔滑意的应用程序：
1 Opensea 集成 NFT.Storage 以实现安全、平台范围的 NFT 持久性
OpenSea 是去中心化网络上最大的 NFT 市场之一。它合作了 与 IPFS 和 FIlecoin 集成 NFT.Storage 并允许用户“冻结”他们的 NFT 元数据。这个过程允许创作者真正去中心化他们的 NFT，将权力交还给创作者，而不是托管者。
如今， OpenSea 用户可以创建不可变的 NFT 数据以持久存储在 Filecoin 的区块链上，并通过 IPFS 内容 ID 完成检索数据的寻址。 IPFS 内容寻址通过消除“地毯拉动”或 NFT 元数据错位的可能性，为 NFT 托管提供了完美的解决方案。
2 Brave 在其正在进行的 Web3 集成中添加了对 IPFS 的本地支持
在包含自己的加密货币钱包之后，Brave 通过集成 IPFS，继续为其桌面 Web 浏览器添加 Web3 功能。 现在允许用户通过本地解析 IPFS 地址来访问存储在协议上的内容。
整合是多年合作的结果 两个团队之间的合作， 目标是让最终用户尽可能地访问 IPFS。这是朝着将 IPFS 转变为所有浏览器最终可能支持的公认互联网标准迈出的一大步。
3 Opera 扩展了对 IPFS 协议寻址的支持
Opera 于 2020 年首次在其 Android 浏览器中添加了对 IPFS 的支持 。今年，它将相同的功能扩展到其Opera Touch iOS 用户的浏览器，允许他们导航到 ipfs:// 和 ipns:// 地址。
4 Pinata 让任何人都可以轻松利用 IPFS
这种固定和文件管理服务允许用户以简单无缝的方式存储区块链经常引用的内容。 Pinata 充分利用IPFS 固定服务 API 将内容发布到 IPFS 网络，允许基于 CID 的去中心化存储和高效检索 。
5 ScalaShare 通过 IPFS 为 Web3 带来了安全的文件共享
互联网上用户之间的文件共享始于 P2P 共享，但ScalaShare 带来了 在 IPFS 的帮助下将此功能应用于 Web3。 对于那些不愿意将数据交给大公司的人来说，这圆闹个简单的开源工具可能会成为首选的文件存储系统。
6 Audius 依靠 CID 按需流式传输音乐
Audius 将 Web3 上的音乐流媒体服务带入了一个新的方向。 Audius使用 IPFS 集成来存储和检索数据 可以确保没有断开的曲目链接，并且所有音乐都交付给用户，而不依赖于集中式服务器 。
IPFS 的 CID 是确保此音乐流媒体服务正常运行并继续使用的关键 流行的 Web 2.0 应用程序（如 TikTok）上的 Web3 基础架构。
7 Palm 在其可持续的 NFT 平台上使用 IPFS 进行存储
这个相对较新的 NFT 工作室最近与 IPFS 合作。Palm 具有用于生成 NFT 的可持续架构。它使用基于代币的经烂腊济来维持具有快速交易时间和低gas费用的生态系统，所有这些都基于节能技术。 IPFS 提供了它需要的解决方案，以确保用户始终可以访问他们的工作 。
8 Valist 信任 IPFS 以实现安全的 Web3 软件分发
通过网站或应用商店发布软件有时会引入安全问题，正如 2020 SolarWinds 攻击所证明的那样。Valist通过允许开发团队以 Web3-native 方式分发软件来解决这个问题。 IPFS 通过提供大量开箱即用的安全保证，充当 Valist 的主要存储层。
9 Snapshot 确保 DAO 投票过程通过 IPFS 去中心化
流行的 DAO 投票系统快照 依赖 IPFS 作为其基础设施的核心部分。 它允许 DAO 成员通过去中心化投票过程就特定协议提案达成共识。快照是从产品到协议的一切社区治理不断增长的空间中最常用的工具之一
技术更新
2021 年还见证了 IPFS 工作方式的多项技术更新。其中的核心是：
1 IPFS 0.11.0
这是面向 Go 开发人员的 IPFS 实现。除了重要的修复之外， 最新版本还改进了 UnixFS 分片和 PubSub 实验以及对 Circuit-Relay v2 的支持 。在这一年中，还进行了其他改进，例如：
对 go-ipfs 的 IPLD 内部结构的更改使使用非 UnixFS DAG 更容易提供多种新命令和配置选项网关支持通过 DAG 导出端点下载任意 IPLD 图自定义 DNS 解析器支持非 ICANN DNSLink 名称单独打包的迁移为 Apple M1 硬件构建固定服务的 WebUI 支持远程固定服务更快的固定和取消固定
2 JS IPFS 0.60.0
JS IPFS 是基于 JavaScript 的类似实现。 它缓解了将 IPFS 数据与 JavaScript 应用程序链接的问题，允许开发人员使用它来本地访问 IPFS 数据 。最新版本包括重要的错误修复，并且全年进行了重要的改进，例如：
ESM 和 CJS 双重发布一个更简单的 globSource APIPubSub 支持解决浏览器连接限制ipfs.get 上的压缩包输出默认从 RSA 切换到 Ed25519Dag 导入导出实现更好的类型定义启用 NAT UPnP 打孔在 ipfs-http-client 中添加了对支持远程固定服务的支持
3 IPFS 集群 0.14.1
用于设置和运行 IPFS 集群的源代码 。这个开源发行版向更多用户和开发人员打开了 IPFS 的世界。在这一年中，它收到了更新，包括：
提高可以列出 pinset 的速度将内容迁移到新集群时更灵活CAR导入支持批量固定摄取对 Badger 数据存储的自动垃圾收集
为了更好地理解为什么这些改进很重要，请务必查看本技术指南 到 IPFS。
采用的下一步
尽管 IPFS 在去年取得了长足的进步，但仍有增长空间。新的合作伙伴关系和进步将是更广泛的 Web3 可用性的关键。 随着越来越多的主流用户意识到对去中心化互联网的需求，对 IPFS 等工具的需求将会增加 。随着他们继续进入这个领域，我们将看到 2022 年会带来什么。
㈧ Flink源码1-Flink 的集群和Jobmanager启动
1、ActorSystem 是管理 Actor生命周期的组件， Actor是负责进行通信的组
2、每个 Actor 都有一个 MailBox，别的 Actor 发送给它的消息都首先储存在 MailBox 中，通过这种 方式可以实现异步通信。
3、每个 Actor 是单线程的处理方式，不断的从 MailBox 拉取消息执行处理，所以对于 Actor 的消息处 理，不适合调用会阻塞的处理方法。
4、Actor 可以改变他自身的状态，可以接收消息，也可以发送消息，还可以生成新的 Actor
5、每一个ActorSystem 和 Actor都在启动的时候会给定一个 name，如果要从ActorSystem中，获取一 个 Actor，配世则通过以下的方式来进行 Actor的获取： akka.tcp://asname@bigdata02:9527/user/actorname 6、如果一个 Actor 要和另外一个 Actor进行通信，则必须先获取对方 Actor 的 ActorRef 对象，然 后通过该对象发送消息即可。
7、通过 tell 发送异步消息，不接收响应，通过 ask 发送异步消息，得到 Future 返回，通过异步回到 返回处理结果
Flink 中的 RPC 实现主要在 flink-runtime 模块下的 org.apache.flink.runtime.rpc 包中，涉及
到的最重要的 API 主要是以下这四个：
1、RpcGateway 路由，RPC的老祖宗，各种其他RPC组件，都是 RpcGateWay 的子类
2、RpcServer RpcService 和 RpcEndpoint 之间的粘合层
3、RpcEndpoint 业务逻辑载体，对应的 Actor 的封装
4、RpcService 对应 ActorSystem 的封装
RpcEndpoint 下面有四个比较重要的子类：
1、TaskExecutor 2、Dispatcher 3、JobMaster 4、ResourceManager
创建成功了之后，都会要去执
行他的 onStart() ，在集群启动的源码分析中，其实这些组件的很多的工作流程，都被放在 onStart() 里
面。
flink-dist 子项目中，位于 flink-bin 下的 bin 目录：启动脚本为：start�cluster.sh
会首先调用 config.sh 来获取 masters 和 workers，masters 的信息，是从 conf/masters 配置
文件中获取的， workers 是从 conf/workers 配置文件中获取的。然后分别：
1、通过 jobmanager.sh 来启动 JobManager
2、通过 taskmanager.sh 来启动 TaskManager
内部，都通过 flink-daemon.sh 脚本来启动 JVM 进程，分析 flink-daemon.sh 脚本发培誉肢现：
1、JobManager 的启动代号：standalonesession，实现类是：
2、TaskManager 的启动代号：taskexecutor，实现类是：TaskManagerRunner
1、ResourceManager Flink的集群资源管理器，只有一个，关于slot的管理和申虚源请等工作，都由他负责 2、Dispatcher 负责接收用户提交的 JobGragh, 然后启动一个 JobManager， 类似于 YARN 集群中的 AppMaster 角色，类似于 Spark Job 中的 Driver 角色
3、JobManager 负责一个具体的 Job 的执行，在一个集群中，可能会有多个 JobManager 同时执行，类似于 YARN 集群中的 AppMaster 角色，类似于 Spark Job 中的 Driver 角色
4、WebMonitorEndpoint 里面维护了很多很多的Handler，如果客户端通过 flink run 的方式来提交一个 job 到 flink 集群，最终，是由 WebMonitorEndpoint 来接收，并且决定使用哪一个 Handler 来执行处理 submitJob ===> SubmitJobHandler
JobManager的启动主类：
org.apache.flink.runtime.entrypoint.
-------------------源码开始 1、 webMonitor 启动 ---------------------
#main（）
▼
/** 注释：创建
*/
entrypoint = new
(configuration);
clusterComponent = .create(
↓
***1重点方法 #create
▼
(163行) webMonitorEndpoint.start(); //
------------------- 2 、Resourcemanager启动部分 2：14：00 ----------------
167行）resourceManager = resourceManagerFactory.createResourceManager
↓
ResourceManagerFactory#createResourceManager
↓
#createResourceManager
↓
ResourceManager#构造函数
当执行完毕这个构造方法的时候，会触发调用 onStart() 方法执行
↓
FencedRpcEndpoint#构造函数
↓
RpcEndpoint#构造函数
▼
this.rpcServer = rpcService.startServer(this);
↓
AkkaRpcService#startServer
.......▲▲（回到ResourceManager类Onstart）
ResourceManager#Onstart() —— 2：24：00
——》ResourceManager#startResourceManagerServices
▼
// TODO_MA 注释： 注意这个 this 对象
// TODO_MA 注释： 执行选举，成功之后，调用 leaderElectionService.isLeader()
// TODO_MA 注释： this = ResourceManager
leaderElectionService.start(this);
↓
#start
▼
/*** 注释： Fink 的 选举，和 HBase 一样都是通过 ZooKeeper 的 API 框架 Curator 实现的
* 1、leaderLatch.start(); 事实上就是举行选举
* 2、当选举结束的时候：
* 如果成功了： isLeader()
* 如果失败了： notLeader()
/
leaderLatch.addListener(this);
leaderLatch.start();
——》#isLeader()
▼
/ * 注释： 分配 LeaderShip
* leaderContender = JobManagerRunnerImpl
* leaderContender = ResourceManager
* leaderContender = DefaultDispatcherRunner
* leaderContender = WebMonitorEndpoint
*
* leaderElectionService.start(this);
* leaderContender = this
/
leaderContender.grantLeadership(issuedLeaderSessionID);
↓
ResourceManager#grantLeadership
(ignored) -> tryAcceptLeadership
↓ 实现类为 ResourceManager
——》ResourceManager# tryAcceptLeadership
▼
/ 注释： 启动服务
* 1、启动心跳服务 启动两个定时任务
* 2、启动 SlotManager 服务 启动两个定时任务
/
startServicesOnLeadership();
▼
/
* 注释： 开启心跳服务
*/
startHeartbeatServices();
------------------- 3、 Dispatcher启动部分 2：47 ：00 ----------------
回到 ： #create 方法
dispatcherRunner = dispatcherRunnerFactory .createDispatcherRunner(highAvailabilityServices.(), fatalErrorHandler,// TODO_MA 注释： 注意第三个参数
new (highAvailabilityServices), ioExecutor, rpcService, partialDispatcherServices);
↓
#createDispatcherRunner
return DefaultDispatcherRunner.create
——》DefaultDispatcherRunner#create
return .createFor
——》#createFor
return new <>(dispatcherRunner, leaderElectionService);
——》构造函数
/*** * 又开启了选举 ，同上resourcemanager相同
* 这个选举服务对象 leaderElectionService 内部的 leaderContender 是 ：
** DefaultDispatcherRunner
leaderElectionService.start(dispatcherRunner);
↓
——》同上节一样启动 #isLeader()
leaderContender.grantLeadership(issuedLeaderSessionID);
↓ 实现类为 DefaultDispatcherRunner
DefaultDispatcherRunner#grantLeadership
* 注释： 开启 Dispatcher 服务
runActionIfRunning(() -> (leaderSessionID));
——》DefaultDispatcherRunner#
thenRun(newDispatcherLeaderProcess::start))
↓
#start
——》#startInternal
onStart()
↓
#onStart()
▼
/* 注释： 开启服务: 启动 JobGraghStore
* 一个用来存储 JobGragh 的存储组件
/
startServices();
// TODO_MA 注释： 到现在为止，依然还没有启动 Dispatcher
.thenAccept(this::createDispatcherIfRunning)
——》#createDispatcherIfRunning
——》 #createDispatcher
final DispatcherGatewayService dispatcherService = .create(
↓
#create
▼
/ 注释： 创建 Dispatcher
dispatcher = dispatcherFactory.createDispatcher(rpcService, fencingToken, bootstrap,
↓
SessionDispatcherFactory#createDispatcher
return new StandaloneDispatcher(rpcService, fencingToken, dispatcherBootstrap,
↓
StandaloneDispatcher构造函数
↓ StandaloneDispatcher为RPCendpoint类
Dispatcher 类 Onstart方法
▼
* 注释： 启动 Dispatcher 服务
*/
startDispatcherServices();
* 注释： 引导程序初始化
* 把所有中断的 job 恢复执行
*/
dispatcherBootstrap.initialize(this,
↓
DefaultDispatcherBootstrap#initialize
launchRecoveredJobGraphs(dispatcher, recoveredJobs);
↓
AbstractDispatcherBootstrap#launchRecoveredJobGraphs
* 注释： 恢复执行 待恢复的 Job
*/
dispatcher.runRecoveredJob(recoveredJob);
▼
* 注释： 调用 runJob 运行一个任务
FutureUtils.assertNoException(runJob(recoveredJob).handle
——》Dispatcher#runJob
......▲▲▲▲（回到）结束 3：17 ：00
㈨ j2ee服务器有哪些
众所周知，J2EE应用服务器百花齐放，种类众多。那么J2EE应用服务器有哪些?又有哪些功能呢?一起来蚂橘渣看看吧!
伍袭从功能实现上划分：
有实现完整J2EE规范(full profile)的Weblogic, WebSphere, GlassFish
有实现web应用规范(web profile)的 TomEE, JBoss/WildFly
有基本的Servlet及Jsp规范的Web容器(Web Container) Tomcat, Jetty, Resin
回顾过去的2015年，各应用服务器市场占有率各有千秋。
下图为各个应用服务器使用率饼图
我们看到，在众多J2EE应用服务器中，Tomcat使用率达到58.66%，稳坐第一。
相较2014年，Tomcat使用率大幅增长，增长将近19%。
整体而言，Tomcat做为Servlet和Jsp规范的参考实现(Reference implementation ， 简称RI)，一般都会在第一时间实现规范的新特性并通过Oracle的CTS 测试认证。目前最新的Tomcat 9.0，虽还是alpha版，但已经实现了Servlet 4.0草案，感兴趣的朋友，可以下载尝鲜哦!
Tomcat是一个实现了JAVA EE标准的最小的WEB服务器，是Apache 软件基金会的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。因为Tomcat 技术先进、性能稳定，而且开源免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。学习JavaWeb开发一般都使用闷悄Tomcat服务器，该服务器支持全部JSP以及Servlet规范，启动界面如图：
Tomcat 是一款非常优秀的 Java Web 服务器,以致于很多开源 Java 应用服务器(如 JOnAS) 直接集成它作为 servlet 容器。
Tomcat的总体结构
Tomcat中主要涉及Server,Service,Engine,Connector,Host,Context组件，之前用过Tomcat的.童鞋是不是觉得这些组件的名称有点似曾相识的赶脚，没赶脚?!您再想想。好吧，不用你想了，我来告诉你吧。其实在Tomcat二进制分发包解压后,在conf目录中有一个server.xml文件，你打开它瞄两眼看看，是不是发现server.xml文件中已经包含了上述的几个名称。
Tomcat 集群源码的类图
从图中我们可以看出 Tomcat 集群包括以下几个方面的内容:
Session: Session 分为 StandardSession 与ClusterSession 两种,后者用于 Session 复制。
Session Manager: 有用于集群 Session 管理的ClusterSession,也有用于对 Session 进行一般日常管理的,如 PersistentManager,BackupManager,SimpleTcpReplicationManager。
组通迅框架:SessionManager调用组通讯框架进行 Session 的传输,Tomcat采用的组通
讯框架是 tribe,目前 tribe 已被独立为开放的 apache 工程。
Cluster: 方便集群管理而派生出的逻辑概念,可将实际物理机划分为一个 Cluster,也可 将一台物理机上不同端口的实例划分为一个 Cluster,它有一个简单的实现类 SimpleTcpCluster。
1.1 Session
服务器集群通常操纵两种session:
1. Stickysessions: 尽量让同一个客户请求由同一台服务器来处理,这样 sticky sessions 就是 存在于单机服务器中接受客户端请求的 session,它不需要进行 Session 复制,如果这个 单机失败的话,用户必须重新登录网站。
2. Replicatedsessions: 在一台服务器中的 session 状态被复制到集群的其他服务器上,无论 何时,只要 session 改变了,session 数据都要重新全部或部分(依据复制策略)被复制 到其他服务器上。
Tomcat 支持以下三种 session 持久性类型:
1. 内存复制:在 JVM 内存中复制 session状态,使用 Tomcat自带的 SimpleTcpCluster 和SimpleTcpClusterManager类。
2. 数据库持久性:在这种类型中,session 状态保存在一个关系数据库中,服务器使用org.apache.catalina.session.JDBCManager类从数据库中获取 Session 信息。
3. 基于文件的持久性:这里使用类org.apache.catalina.session.FileManager 把session 状态保存到一个文件系统。
Session Manager
Tomcat 通过 org.apache.catalina.Manager 来管理 Session,Manager 接口总是和 Context Container 相关联。它主要负责 session 的建立、更新和销毁。该接口中一些重要的方法有:
用户在 Servlet 中通过 javax.servlet.http.HttpServletRequest 接口的 getSession 方法获得 Session,而该接口的实现位于 org.apache.catalina.connector.Request 类中的 doGetSession 方 法中,在该方法中通过 org.apache.catalina.Manager 来获得 Session , doGetSession 方法的 部分代码如下:
组通讯框架--Tribe
组通讯框架 Tribe 在 Tomcat 中的位置可如下图
如图所示,Tribe 的核心主要是 Channel 类,由此看出,它采用 NIO 进行 Socket 通讯,运用
了组播,事件、心跳检测等技术,下面我们来着重看看代码中 Tomcat 是如何与 Tribe 衍接首先在 SimpleTcpReplication 类中的实现 Manager 接口的 start 方法中:
Cluster
Cluster 用于管理集群中的 Session 复制,它有一个简单的实现类 SimpleTcpCluster。
㈩ 一文解密Kafka，Kafka源码设计与实现原理剖析，真正的通俗易懂
Apache Kafka （简称Kafka ）最早是由Linkedln开源出来的分布式消息系统，现在是Apache旗下的一个子项目，并且已经成为开册、领域应用最广泛的消息系统之 Kafka社区也非常活跃，从 版本开始， Kafka 的标语已经从“一个高吞吐量、分布式的消息系统”改为“一个分布式的流平台”
关于Kafka，我打算从入门开始讲起，一直到它的底层实现逻辑个原理以及源码，建议大家花点耐心，从头开始看，相信会对你有所收获。
作为 个流式数据平台，最重要的是要具备下面 个特点
消息系统：
消息系统 也叫作消息队列）主要有两种消息模型：队列和发布订Kafka使用消费组（ consumer group ）统 上面两种消息模型 Kafka使用队列模型时，它可以将处理 作为平均分配给消费组中的消费者成员
下面我们会从 个角度分析Kafka 的几个基本概念，并尝试解决下面 个问题
消息由生产者发布到 fk 集群后，会被消费者消费 消息的消费模型有两种：推送模型（ pu和拉取模型（ pull 基于推送模型的消息系统，由消息代理记录消费者的消费状态 消息代理在将消息推送到消费者后 标记这条消息为已消费
但这种方式无法很好地保证消息的处理语义 比如，消息代理把消息发送出去后，当消费进程挂掉或者由于网络原因没有收到这条消息时，就有可能造成消息丢失（因为消息代理已经 这条消息标记为自己消费了，但实际上这条消息并没有被实际处理） 如果要保证消息的处理语义，消息代理发送完消息后，要设置状态为“已发送”，只有收到消费者的确认请求后才更新为“已消费”，这就需要在消息代理中记录所有消息的消费状态，这种做法也是不可取的
Kafka每个主题的多个分区日志分布式地存储在Kafka集群上，同时为了故障容错，每个分区都会以副本的方式复制到多个消息代理节点上 其中一个节点会作为主副本（ Leader ），其 节点作为备份副本（ Follower ，也叫作从副本）
主副本会负责所有的客户端读写操作，备份副本仅仅从主副本同步数据 当主副本 IH 现在故障时，备份副本中的 副本会被选择为新的主副本 因为每个分区的副本中只有主副本接受读写，所以每个服务端都会作为某些分区的主副本，以及另外一些分区的备份副本这样Kafka集群的所有服务端整体上对客户端是负载均衡的
消息系统通常由生产者“pro ucer 消费者（ co sumer ）和消息代理（ broke 大部分组成，生产者会将消息写入消息代理，消费者会从消息代理中读取消息 对于消息代理而言，生产者和消费者都属于客户端：生产者和消费者会发送客户端请求给服务端，服务端的处理分别是存储消息和获取消息，最后服务端返回响应结果给客户端
新的生产者应用程序使用 af aP oce 对象代表 个生产者客户端进程 生产者要发送消息，并不是直接发送给 务端 ，而是先在客户端 消息放入队列 然后 一个 息发送线程从队列中消息，以 盐的方式发送消息给服务端 Kafka的记 集器（ Reco dACCUl'lUlato ）负责缓存生产者客户端产生的消息，发送线程（ Sende ）负责读取 集器的批 过网络发送给服务端为了保证客户端 络请求 快速 应， Kafka 用选择器（ Selecto 络连接 读写 理，使网络连接（ Netwo kCl i.ent ）处理客户端 络请求
追加消息到记录收集器时按照分区进行分组，并放到batches集合中，每个分区的队列都保存了将发送到这个分区对应节点上的 记录，客户端的发送线程可 只使用 Sende 线程迭 batches的每个分区，获取分区对应的主剧本节点，取出分区对应的 列中的批记录就可以发送消息了
消息发送线程有两种消息发送方式 按照分区直接发送 按照分区的目标节点发迭 假设有两台服务器， 题有 个分区，那么每台服务器就有 个分区 ，消息发送线程迭代batches的每个分 接往分区的主副本节点发送消息，总共会有 个请求 所示，我 先按照分区的主副本节点进行分组， 属于同 个节点的所有分区放在一起，总共只有两个请求做法可以大大减少网络的开销
消息系统由生产者 存储系统和消费者组成 章分析了生产者发送消息给服务端的过程，本章分析消费者从服务端存储系统读取生产者写入消息的过程 首先我 来了解消费者的 些基础知识
作为分布式的消息系统， Kafka支持多个生产者和多个消费者，生产者可以将消息发布到集群中不同节点的不同分区上；“肖费者也可以消费集群中多个节点的多个分区上的消息 写消息时，多个生产者可以 到同 个分区 读消息时，如果多个消费者同时读取 个分区，为了保证将日志文件的不同数据分配给不同的消费者，需要采用加锁 同步等方式，在分区级别的日志文件上做些控制
相反，如果约定“同 个分区只可被 个消费者处理”，就不需要加锁同步了，从而可提升消费者的处理能力 而且这也并不违反消息的处理语义：原先需要多个消费者处理，现在交给一个消费者处理也是可以的 3- 给出了 种最简单的消息系统部署模式，生产者的数据源多种多样，它们都统写人Kafka集群 处理消息时有多个消费者分担任务 ，这些消费者的处理逻辑都相同， 每个消费者处理的分区都不会重复
因为分区要被重新分配，分区的所有者都会发生变 ，所以在还没有重新分配分区之前 所有消费者都要停止已有的拉取钱程 同时，分区分配给消费者都会在ZK中记录所有者信息，所以也要先删ZK上的节点数据 只有和分区相关的 所有者 拉取线程都释放了，才可以开始分配分区
如果说在重新分配分区前没有释放这些信息，再平衡后就可能造成同 个分区被多个消费者所有的情况 比如分区Pl 原先归消费者 所有，如果没有释放拉取钱程和ZK节点，再平衡后分区Pl 被分配给消费者 了，这样消费者 和消费者 就共享了分区Pl ，而这显然不符合 fka 中关于“一个分区只能被分配给 个消费者”的限制条件 执行再平衡操作的步骤如下
如果是协调者节点发生故障，服务端会有自己的故障容错机制，选出管理消费组所有消费者的新协调者节，点消费者客户端没有权利做这个工作，它能做的只是等待一段时间，查询服务端是否已经选出了新的协调节点如果消费者查到现在已经有管理协调者的协调节点，就会连接这个新协调节，哉由于这个协调节点是服务端新选出来的，所以每个消费者都应该重新连接协调节点
消费者重新加入消费组，在分配到分区的前后，都会对消费者的拉取工作产生影响 消费者发送“加入组请求”之前要停止拉取消息，在收到“加入组响应”中的分区之后要重新开始拉取消息时，为了能够让客户端应用程序感知消费者管理的分区发生变化，在加入组前后，客户端还可以设置自定义的“消费者再平衡监听器”，以便对分区的变化做出合适的处理