Update 分布式.md

补充 etcd Watch 的续看与压缩后的恢复、XXL-JOB 的时间轮与调度过期策略、多实例用 SKIP LOCKED 领取到期任务(新增附录 A8)、支付回调后续动作的事务边界,以及雪花算法、Raft 等小节的校对。
This commit is contained in:
CyC2018
2026-11-07 17:10:27 +08:00
parent e3c07c59ac
commit 2770e330b5
+75 -38
View File
@@ -51,13 +51,14 @@
* [A5 定时任务的重复执行与加锁](#a5-定时任务的重复执行与加锁)
* [A6 分片与按分片重试](#a6-分片与按分片重试)
* [A7 MySQL 行锁实现的分布式锁](#a7-mysql-行锁实现的分布式锁)
* [A8 SKIP LOCKED 领取到期任务](#a8-skip-locked-领取到期任务)
* [参考资料](#参考资料)
<!-- GFM-TOC -->
## 一、分布式锁 🔥🔥
在单机场景下,可以使用语言的内置锁来实现进程同步。但是在分布式场景下,需要同步的进程可能位于不同的节点上,那么就需要使用分布式锁。
在一个进程内,可以使用语言的内置锁来实现线程同步。但是在分布式场景下,需要同步的进程可能位于不同的节点上,那么就需要使用分布式锁。
分布式锁把“锁是否被占用”保存在所有节点都能访问的地方,例如数据库中的一行、Redis 中的一个键、ZooKeeper 中的一个节点。下面的几种实现都要解决同样的几个问题:
@@ -87,7 +88,7 @@ COMMIT;
其它客户端执行同一条语句时阻塞,超过 innodb_lock_wait_timeout(默认 50 秒)返回错误;加上 NOWAIT 时拿不到锁立即返回错误,相当于非阻塞锁。持有锁的进程崩溃后连接断开,事务回滚,锁立即释放:kill -9 持有锁的进程后,等待中的客户端马上拿到了锁(MySQL 8.0 实测,见[附录 A7](#a7-mysql-行锁实现的分布式锁))。
需要注意的是,持有锁的机器宕机或网络中断时,MySQL 收不到断开的通知,要等这个空闲连接超过 wait_timeout(默认 8 小时)才回滚。可以为持有锁的连接调小 wait_timeout,但要大于持锁期间连接空闲的最长时间(例如调用远程服务),否则业务还没执行完锁就被释放了。
需要注意的是,持有锁的机器宕机或网络中断时,MySQL 收不到断开的通知,要等 TCP keepalive 判定连接失效(MySQL 为客户端连接开启了 keepalive,按 Linux 的默认参数约 2 小时 11 分钟),或者空闲超过 wait_timeout(默认 8 小时)才回滚。可以为持有锁的连接调小 wait_timeout,但要大于持锁期间连接空闲的最长时间(例如调用远程服务),否则业务还没执行完锁就被释放了。
代价是持有锁期间一直占用一个数据库连接和一个未提交的事务,并发高时会耗尽连接池。
@@ -95,7 +96,7 @@ COMMIT;
SETNX(SET if Not eXists)命令在键不存在时写入并返回 1,键已经存在时什么也不做并返回 0。它和数据库的唯一索引类似,可以用这个键是否存在来判断是否处于锁定状态。
EXPIRE 命令可以为键设置过期时间,从而避免了释放锁失败的问题。但是 SETNX 和 EXPIRE 是两条命令,不具有原子性,如果执行完 SETNX 之后进程崩溃,那么这个锁就永远不会过期。因此应该使用 SET 命令的 NX 和 PX 选项一次性完成加锁和设置过期时间(Redis 2.6.12 起官方也把 SETNX 视为弃用):
EXPIRE 命令可以为键设置过期时间,从而避免了释放锁失败的问题。但是 SETNX 和 EXPIRE 是两条命令,不具有原子性,如果执行完 SETNX 之后进程崩溃,那么这个锁就永远不会过期。因此应该使用 SET 命令的 NX 和 PX 选项(PX 以毫秒为单位设置过期时间,下例为 30 秒)一次性完成加锁和设置过期时间(Redis 2.6.12 起官方也把 SETNX 视为弃用):
```text
SET lock_key unique_value NX PX 30000
@@ -134,7 +135,7 @@ Redis 8.4 新增了 `DELEX lock_key IFEQ unique_value` 命令,可以直接原
续期也可能失败,例如持有者与 Redis 之间的网络中断超过 30 秒:看门狗只记录日志并重试,不通知业务线程,锁过期后被其它客户端拿到,原持有者却还在执行,只能靠栅栏令牌或数据库约束兜底。之后原持有者解锁时,脚本发现字段“客户端 UUID:线程 ID”不存在,不会删掉别人的锁,unlock() 抛出 IllegalMonitorStateException。
调用 lock(10, TimeUnit.SECONDS) 指定了过期时间时,Redisson 不启动看门狗,10 秒后锁被自动删除,即使业务还没有执行完。需要注意的是,Redisson 的锁仍然保存在一个 Redis 主节点上。有从节点时,它加锁后默认执行 WAIT 等从节点确认,能缩小丢锁的窗口;但故障转移不一定选中收到这把锁的从节点,仍不能保证不丢。对正确性要求高的场景,资源端用下文 [RedLock](#redis-的-redlock-算法) 一节的栅栏令牌或 ZooKeeper,并以数据库的唯一约束、条件更新兜底。
调用 lock(10, TimeUnit.SECONDS) 指定了过期时间时,Redisson 不启动看门狗,10 秒后锁被自动删除,即使业务还没有执行完。需要注意的是,Redisson 的锁仍然保存在一个 Redis 主节点上。有从节点时,它加锁后默认执行 [WAIT](Redis.md#十二sentinel) 等从节点确认,能缩小丢锁的窗口;但故障转移不一定选中收到这把锁的从节点,仍不能保证不丢。对正确性要求高的场景,资源端用下文 [RedLock](#redis-的-redlock-算法) 一节的栅栏令牌或 ZooKeeper,并以数据库的唯一约束、条件更新兜底,见[幂等](#九幂等)。
<div align="center"> <img src="pics/redis-lock-failover.png" width="760px"/> </div><br>
@@ -146,7 +147,7 @@ RedLock 使用多个互相独立的 Redis 实例(通常是 5 个)实现分
- 计算获取锁消耗的时间,只有时间小于锁的过期时间,并且从大多数(N / 2 + 1)实例上获取了锁,才认为获取锁成功;
- 如果获取锁失败,就到每个实例上释放锁。
实例崩溃重启也会破坏多数派:例如 5 个实例中客户端 A 在 1、2、3 上加锁,3 号断电重启后丢了这个键,客户端 B 就能在 3、4、5 上再拿到多数。官方文档给出的办法是开启 AOF 并设置 appendfsync always,让每次写入都刷盘,或者让崩溃的实例延迟重启,不可用的时间超过最长的锁过期时间后再加入。
实例崩溃重启也会破坏多数派:例如 5 个实例中客户端 A 在 1、2、3 上加锁,3 号断电重启后丢了这个键,客户端 B 就能在 3、4、5 上再拿到多数。官方文档给出的办法是开启 [AOF](Redis.md#aof-持久化) 并设置 appendfsync always,让每次写入都刷盘,或者让崩溃的实例延迟重启,不可用的时间超过最长的锁过期时间后再加入。
RedLock 不要求各节点的时钟同步,但假设各节点的时钟走速大致相同,时钟跳变(例如被 NTP 大幅校正)会让锁提前过期,这是它存在争议的原因之一。
@@ -164,7 +165,7 @@ RedLock 不要求各节点的时钟同步,但假设各节点的时钟走速大
UPDATE inventory SET stock = 97, fence = 8 WHERE sku_id = 10086 AND fence <= 8;
```
RedLock 使用的随机值不是递增的,算法本身无法提供栅栏令牌;ZooKeeper 则可以使用加锁时创建的节点的事务 ID(czxid),它在整个集群中单调递增。有序节点的序号不适合作令牌:序号的计数器属于父节点,Curator 把锁的父节点建成容器节点,锁空闲后父节点会被删除,序号又从 0 开始。
RedLock 使用的随机值不是递增的,算法本身无法提供栅栏令牌;ZooKeeper 则可以使用加锁时创建的节点的事务 ID(czxid,即创建该节点的事务的 zxid,见[日志复制](#日志复制)),它在整个集群中单调递增。[有序节点](#2-节点类型)的序号不适合作令牌:序号的计数器属于父节点,ZooKeeper 的客户端 Curator 把锁的父节点建成容器节点(最后一个子节点删除后由服务端自动删除),锁空闲后父节点会被删除,序号又从 0 开始。
Redisson 已把 RedLock 标为弃用,改为推荐 RLock 加上主从同步检查;需要令牌时用 RFencedLock,它在加锁时对一个计数键执行 INCR,返回值作为令牌。这个计数键和锁在同一个主节点上,主从复制是异步的,故障转移后计数可能回退,令牌不再严格递增,所以它同样不能完全排除旧持有者的写入。
@@ -172,7 +173,7 @@ Redisson 已把 RedLock 标为弃用,改为推荐 RLock 加上主从同步检
#### 1. ZooKeeper 抽象模型
ZooKeeper 提供了一种树形结构的命名空间,/app1/p_1 节点的父节点为 /app1。
ZooKeeper 提供了一种树形结构的命名空间,/app1/p_1 节点的父节点为 /app1。客户端连接 ZooKeeper 后建立一个会话(session),靠定期发送心跳维持,集群在会话超时时间内没有收到心跳就让会话过期。
<div align="center"> <img src="pics/zk-namespace.png" width="760px"/> </div><br>
@@ -232,7 +233,7 @@ ZooKeeper 提供了一种树形结构的命名空间,/app1/p_1 节点的父节
- 锁解决的是互斥,例如多个进程同时修改同一个账户的余额;
- 事务解决的是一组操作要么都执行、要么都不执行。
下面介绍的几种做法,常用的分布式事务框架 Seata 都提供了实现。Seata 中有三个角色:事务协调者(Transaction Coordinator, TC)是单独部署的服务,记录全局事务和各个分支事务的状态,驱动它们提交或回滚;事务管理器(Transaction Manager, TM)在发起全局事务的服务中,负责开始、提交或回滚全局事务;资源管理器(Resource Manager, RM)在每个参与的服务中,负责注册分支事务、报告状态并执行提交或回滚。它提供四种模式:
下面介绍的 2PC、TCC 和 Saga,常用的分布式事务框架 Seata 都提供了实现。Seata 中有三个角色:事务协调者(Transaction Coordinator, TC)是单独部署的服务,记录全局事务和各个分支事务的状态,驱动它们提交或回滚;事务管理器(Transaction Manager, TM)在发起全局事务的服务中,负责开始、提交或回滚全局事务;资源管理器(Resource Manager, RM)在每个参与的服务中,负责注册分支事务、报告状态并执行提交或回滚。它提供四种模式:
- XA:即下文的 2PC,由数据库执行 XA PREPARE,锁一直持有到第二阶段;
- AT:第一阶段直接提交本地事务,同时记录修改前后的数据,失败时按记录生成反向的 SQL 回滚,对业务代码没有侵入,过程见 [微服务中的 Seata](微服务.md#七服务保护与分布式事务);
@@ -420,7 +421,7 @@ BASE 理论是对 CAP 中一致性和可用性权衡的结果,它的核心思
- 弱一致性:写入之后不保证马上能读到新值;
- 最终一致性:弱一致性的一种,保证不再有新的写入时,所有副本最终都会相同。
例如订单 1024 支付成功后,主库中已经是“已支付”,从库在复制完成之前仍返回“待支付”。强一致的系统不允许出现这种情况,最终一致的系统允许,但复制完成后必须读到“已支付”。强一致和最终一致之间还有因果一致性等模型,它只保证有因果关系的写入按先后被看到,例如看到订单 1024“已发货”的用户,一定也能看到它“已支付”。
例如订单 1024 支付成功后,主库中已经是“已支付”,从库在复制完成之前仍返回“待支付”。强一致的系统不允许出现这种情况,最终一致的系统允许,但复制完成后必须读到“已支付”。强一致和最终一致之间还有因果一致性等模型,它只保证有因果关系的写入按先后被看到,例如发货记录是在读到订单 1024 的支付记录之后写入的,能查到这条发货记录的用户,一定也能查到支付记录。
ACID 要求每个事务结束时数据都满足约束,并且事务之间相互隔离,通常运用在传统的数据库系统上。而 BASE 允许数据在一段时间内处于中间状态,只要求最终一致,通过牺牲强一致性来达到可用性,通常运用在大型分布式系统中。
@@ -489,21 +490,21 @@ Acceptor 接受一个提议之后,会将该提议发送给所有的 Learner。
指最后总会有一个提议生效。
Paxos 并不能严格保证可终止性:如果两个 Proposer 交替地使用更大的序号发送 Prepare 请求,那么双方的 Accept 请求都会一直被拒绝,形成活锁。实际中通常会选出一个主 Proposer,只由它来发起提议(Multi-Paxos 的做法),或者在重试前随机等待一段时间。
Paxos 并不能严格保证可终止性:如果两个 Proposer 交替地使用更大的序号发送 Prepare 请求,那么双方的 Accept 请求都会一直被拒绝,形成活锁。实际中通常会选出一个主 Proposer,只由它来发起提议(Multi-Paxos 的做法,每个日志位置对应一个 Paxos 实例,第 i 个实例选出的值就是第 i 个操作),或者在重试前随机等待一段时间。
## 六、Raft
Raft 也是分布式共识算法,相比于 Paxos 更容易理解和实现。它将共识问题分解为 Leader 选举、日志复制和安全性三个子问题,etcd、Consul 等系统都使用了 Raft。
Raft 也是分布式共识算法,相比于 Paxos 更容易理解和实现。实际系统要达成一致的通常是一串写操作:每个写操作作为一条日志按顺序追加,各节点按相同的顺序执行这些日志,得到的数据就相同。Raft 将这个问题分解为 Leader 选举、日志复制和安全性三个子问题,etcd、Consul 等系统都使用了 Raft。
### 单个 Candidate 的竞选
有三种节点:Follower、Candidate 和 Leader。Raft 把时间划分为多个任期(Term),任期号单调递增,每个任期从一次选举开始,并且每个任期内最多只有一个 Leader。任期号的作用和 Paxos 中的提议序号相同,发生冲突时任期号大的一方说了算。
Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间,论文中的例子是 150ms\~300ms,如果在这个时间内没有收到 Leader 的心跳包,就会变成 Candidate,将任期号加 1 并给自己投一票,进入竞选阶段。
Leader 会周期性地发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间,论文中的例子是 150ms\~300ms,如果在这个时间内没有收到 Leader 的心跳包,就会变成 Candidate,将任期号加 1 并给自己投一票,进入竞选阶段。
- 系统刚启动时只有 Follower 没有 Leader。Node A 的随机竞选超时最短,到期时没收到 Leader 发来的心跳包,因此进入竞选阶段,发送投票请求给其它所有节点。
- 每个节点在一个任期内最多只能投一票,先到先得,并且只会投给日志至少和自己一样新的 Candidate(比较双方最后一条日志:任期大的更新,任期相同时日志更长的更新),这保证了新的 Leader 一定包含所有已提交的日志。如果 Candidate 获得超过一半节点的选票,就会变成 Leader。
- 每个节点在一个任期内最多只能投一票,先到先得,并且只会投给日志至少和自己一样新的 Candidate(比较双方最后一条日志:任期大的更新,任期相同时日志更长的更新)。如果 Candidate 获得超过一半节点的选票,就会变成 Leader。已提交的日志已经写入大多数节点(见[日志复制](#日志复制)),两个大多数至少有一个公共节点,所以这条规则保证了新的 Leader 一定包含所有已提交的日志。
- 之后 Leader 会周期性地发送心跳包给 Follower,Follower 接收到心跳包,会重新开始计时。
@@ -532,16 +533,16 @@ Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了
发生网络分区时,少数派一侧的旧 Leader 得不到大多数节点的确认,无法提交日志,多数派一侧会选出新的 Leader。分区恢复后,旧 Leader 发现更大的任期号就会退回 Follower,它未提交的日志被覆盖,因此写入不会出现脑裂。
读请求则要另外处理:旧 Leader 如果直接用本地数据回答读请求,可能返回旧数据,所以 Raft 要求 Leader 在处理只读请求前,先与大多数节点交换一次心跳,确认自己仍是 Leader。另外,新 Leader 刚上任时还不知道哪些日志已经提交,要先提交一条当前任期的空日志,之后才能处理只读请求。
读请求则要另外处理:旧 Leader 如果直接用本地数据回答读请求,可能返回旧数据,所以 Raft 要求 Leader 在处理只读请求前,先与大多数节点交换一次心跳,确认自己仍是 Leader。
需要注意的是,Leader 只对当前任期的日志按“大多数节点已写入”判断是否提交。之前任期留下的日志即使已经复制到大多数节点,也可能被之后的 Leader 覆盖,要等当前任期的一条日志提交后才随之提交。这也是上文新 Leader 要先提交一条空日志的原因。
需要注意的是,Leader 只对当前任期的日志按“大多数节点已写入”判断是否提交。之前任期留下的日志即使已经复制到大多数节点,也可能被之后的 Leader 覆盖,要等当前任期的一条日志提交后才随之提交。因此新 Leader 刚上任时还不知道之前任期的日志哪些已经提交,要先提交一条当前任期的空日志,之后才能处理只读请求。
Raft 与 Paxos 达成的结果是等价的,区别在于对 Leader 的依赖程度:
- Paxos 中任何一个 Proposer 都可以发起提议,选出一个主 Proposer 只是性能上的优化(也用来避免上文的活锁)。Multi-Paxos 中日志的每个位置各自独立地确定,新的主节点还要先找回自己缺少的日志;
- Paxos 中任何一个 Proposer 都可以发起提议,选出一个主 Proposer 不影响正确性,作用是保证进展(避免上文的活锁),Multi-Paxos 中稳定的主节点还可以省掉后续位置重复的 Prepare 阶段。Multi-Paxos 中日志的每个位置各自独立地确定,新的主节点还要先找回自己缺少的日志;
- Raft 中选主是协议的一部分,只有 Leader 能追加日志,日志只从 Leader 流向 Follower,投票规则又保证当选的节点包含所有已提交的日志,新 Leader 不需要从其它节点补日志,因此更容易理解和实现。代价是所有写入都要经过 Leader,选举期间不能写入。
ZooKeeper 使用的 ZAB 协议同样以 Leader 为中心,纪元编号(epoch)的作用相当于 Raft 的任期号,它写在事务 ID(zxid)的高 32 位,低 32 位是这个纪元内的计数。
ZooKeeper 使用的原子广播协议(ZooKeeper Atomic Broadcast, ZAB)同样以 Leader 为中心,纪元编号(epoch)的作用相当于 Raft 的任期号,它写在事务 ID(zxid)的高 32 位,低 32 位是这个纪元内的计数。
两者的选举和恢复方式不同。选举时节点先投自己,同一轮选举中收到更好的选票就改投,依次比较候选者当前的纪元编号(currentEpoch)、最后一个 zxid 和节点 ID,得到多数节点支持的候选者当选;Raft 的节点在一个任期内最多投一票,投给最先请求并且日志不比自己旧的候选者,投出后不再改投。
@@ -562,7 +563,7 @@ boolean ok = inventoryService.deduct(10086, 2);
<div align="center"> <img src="pics/rpc-call.png" width="740px"/> </div><br>
1. inventoryService 是框架用动态代理生成的对象,调用它的方法时,代理拿到接口名、方法名和参数;
2. 把这些信息序列化成字节,加上请求 ID 等首部组成请求帧,从注册中心获取的地址列表中按负载均衡选出一个实例,通过长连接发送;
2. 把这些信息序列化成字节,加上请求 ID 等首部组成请求帧,从[注册中心](#服务发现)获取的地址列表中按负载均衡选出一个实例,通过长连接发送;
3. 服务方解码请求,找到对应的实现类,通过反射调用 deduct(),再把返回值按同样的方式发回;
4. 一个连接上可能同时有多个请求在等待响应,调用方根据响应中的请求 ID 把结果交给对应的调用。
@@ -616,7 +617,7 @@ Java 自带的序列化还有安全问题:数据中写着完整的类名,接
Protobuf 的数据中没有类名,解析成哪种消息由接收方调用的生成类决定。Dubbo 3.2 起对 Hessian2、Fastjson2 和泛化调用默认开启严格的类检查,只有允许列表中的类才能被反序列化,允许列表包括框架内置的类、自己配置的类,以及按接口自动扫描得到的类和包。
复用连接之后,要在 TCP 的字节流中分出一个个请求。TCP 不保留消息的边界,所以协议都在消息前写明长度。例如 Dubbo 协议的首部固定为 16 字节:2 字节魔数 0xdabb、1 字节标志(请求还是响应、是否需要返回值、序列化方式)、1 字节响应状态、8 字节请求 ID、4 字节正文长度。接收方先读 16 字节的首部,再按长度读出正文,用请求 ID 找到对应的调用。
复用连接之后,要在 TCP 的字节流中分出一个个请求。TCP 不保留消息的边界(见 [TCP 粘包与拆包](计算机网络%20-%20传输层.md#tcp-粘包与拆包)),所以协议都在消息前写明长度。例如 Dubbo 协议的首部固定为 16 字节:2 字节魔数 0xdabb、1 字节标志(请求还是响应、是否需要返回值、序列化方式)、1 字节响应状态、8 字节请求 ID、4 字节正文长度。接收方先读 16 字节的首部,再按长度读出正文,用请求 ID 找到对应的调用。
### 服务发现
@@ -628,7 +629,9 @@ Protobuf 的数据中没有类名,解析成哪种消息由接收方调用的
因此注册中心全部宕机时,调用方仍然可以按缓存的地址继续调用,只是新上线的实例无法被发现,新启动且本地没有缓存地址的调用方也无法调用。某个实例宕机后、调用方本地的列表更新之前,发往它的请求会失败,需要调用方重试其它实例。
用 ZooKeeper 作注册中心时,每个实例在 /services/inventory-service 下创建一个保存地址的 [临时节点](#2-节点类型),会话超时后节点自动删除,调用方 [监听](#3-监听器) 这个目录的子节点变化;etcd 的做法类似,用绑定租约(lease)的键代替临时节点。
用 ZooKeeper 作注册中心时,每个实例在 /services/inventory-service 下创建一个保存地址的 [临时节点](#2-节点类型),会话超时后节点自动删除,调用方 [监听](#3-监听器) 这个目录的子节点变化;etcd 的做法类似,用绑定租约(lease)的键代替临时节点,租约过期时键被删除,调用方 Watch 服务的前缀就能收到删除事件。
etcd 给整个键值存储维护一个全局的修订号 revision,每个修改事务提交时加 1,同一事务中的多个修改共用一个 revision。连接断开后,从最后完整收到的事件的 revision 加 1 继续 Watch,只要 Watch 没有被取消、需要的历史还在,etcd 的 Go 客户端会自动重连续看;要续看的 revision 已被压缩时 Watch 会被取消(ErrCompacted),这时要重新读取前缀下的全部实例替换本地列表,再从这次读取的响应头中的 revision 加 1 重新 Watch。
Nacos、Eureka、ZooKeeper 的区别,与客户端负载均衡的配合,以及 [实例下线后多久能感知](微服务.md#实例下线后多久能感知)、[注册中心宕机](微服务.md#注册中心宕机) 时的表现,见 [微服务](微服务.md#三注册中心)。
@@ -641,9 +644,9 @@ HTTP 是一种协议,RPC 是一种调用方式,两者不是同一层面的
- 序列化更紧凑:例如参数 {"skuId":10086,"count":2},JSON 需要 25 字节;Protobuf 不传字段名,只传字段编号和值,编码为 08 E6 4E 10 02,共 5 字节,其中 08 表示字段 1,E6 4E 是 10086 的变长编码,10 02 表示字段 2 的值为 2;
- 连接复用:在少量长连接上同时发送多个请求,用请求 ID 区分响应。HTTP/1.1 也能复用连接,但同一个连接上的响应必须按请求的顺序返回,前面一个慢请求会挡住后面的请求;
- 服务治理:内置服务发现、负载均衡、超时重试和熔断,使用 HTTP 时则要由 Spring Cloud 这类框架另外提供;
- 接口约定:用 Java 接口或者 IDL 文件定义服务,自动生成调用方的代码,参数类型在编译期就能检查。跨语言时双方共用一份 IDL,例如 Go 程序用同一个 .proto 文件生成客户端,就能调用 Java 实现的 gRPC 服务。
- 接口约定:用 Java 接口或者接口定义语言(Interface Definition Language, IDL)文件定义服务,自动生成调用方的代码,参数类型在编译期就能检查。跨语言时双方共用一份 IDL,例如 Go 程序用同一个 .proto 文件生成客户端,就能调用 Java 实现的 gRPC 服务。
HTTP + JSON 的优势在于通用:浏览器和各种语言都能直接调用,报文可读,便于调试,适合对外开放的接口。
HTTP + JSON 的优势在于通用:浏览器和各种语言都能直接调用,报文可读,便于调试,适合对外开放的接口。调用方不需要等待结果或者有多个接收方时可以考虑消息队列,区别见 [与 RPC 调用的区别](消息队列.md#与-rpc-调用的区别)。
gRPC 选择 HTTP/2 是因为它的 [多路复用](HTTP.md#二进制分帧层):每次调用是一个流(Stream),请求路径为 /包名.服务名/方法名,例如 /inventory.InventoryService/Deduct;多个调用的帧在同一个连接上交错发送,用流 ID 区分,不需要自己设计请求 ID。参数编码成 Protobuf 后,前面加 1 字节的压缩标志和 4 字节的长度,放在 DATA 帧中。上面的参数在 DATA 帧中就是 00 00 00 00 05 08 E6 4E 10 02,前 5 个字节表示不压缩、长度为 5。
@@ -651,7 +654,7 @@ gRPC 选择 HTTP/2 是因为它的 [多路复用](HTTP.md#二进制分帧层):
- 每次调用都要设置超时时间,否则下游变慢时,调用方的线程会一直等待,最终被耗尽。超时按下游延迟的高分位数设置,例如能接受 0.1% 的请求被误判为超时,就取下游的 P99.9,再加上建立连接和网络的开销,并用压测验证;
- 调用方超时不代表服务方没有执行:请求可能在网络中延迟,或者在服务方的线程池中排队、遇到 GC 停顿,这些时间都计入了调用方的耗时,却不在服务方记录的处理时间里,于是调用方超时了,服务方却执行成功了;
- 因此只有幂等的接口才能自动重试,例如查询;扣库存这类写操作要带上请求 ID,由服务方去重(见 [幂等](#九幂等)),否则重试会扣减两次。需要注意的是,有的框架默认就会重试,例如 Dubbo 默认的集群容错方式是 failover,失败或超时后换一台服务器重试 2 次,一次调用最多执行 3 次,写操作要改为 failfast 或者带上请求 ID;
- 因此只有幂等的接口才能自动重试,例如查询;扣库存这类写操作要由调用方生成一个请求 ID,重试时沿用,由服务方去重(见 [幂等](#九幂等)),否则重试会扣减两次。这个 ID 要放在参数或附加信息中;以 Dubbo 协议为例,首部的请求 ID 每次发送都重新生成,只用来匹配响应。需要注意的是,有的框架默认就会重试,例如 Dubbo 默认的集群容错方式是 failover,失败或超时后换一台服务器重试 2 次,一次调用最多执行 3 次,写操作要改为 failfast 或者带上请求 ID;
- 调用链较长时,下游的超时时间应该比上游短,上游的超时还要容纳下游的重试,否则上游已经放弃,下游仍在重试。gRPC 会把截止时间(deadline)随请求传给服务方,超时后调用方收到 DEADLINE_EXCEEDED,服务方的框架也会取消这次调用,但正在执行的业务代码不会被中断,耗时的处理要自己检查是否已被取消;服务方调用下游时沿用这次请求的上下文,Java 和 Go 的 gRPC 会自动把剩余的时间传下去。
<div align="center"> <img src="pics/rpc-timeout-retry.png" width="760px"/> </div><br>
@@ -679,6 +682,8 @@ gRPC 选择 HTTP/2 是因为它的 [多路复用](HTTP.md#二进制分帧层):
需要注意的是,MySQL 的 UUID() 生成的是基于时间的 v1,时间戳的低位在最前面,短时间内连续生成的值几乎是递增的,接近顺序插入:同样插入 100 万行用时 5.1 秒、数据 164 MB,多出的部分主要来自 36 个字符的长度。
不过,时间戳的低 32 位约每 7 分钟回绕一次,长期写入时新值仍会插到索引中间;MySQL 8.0 可以用 UUID_TO_BIN(UUID(), 1) 把时间的高位换到前面,存成 BINARY(16)。
RFC 9562(2024)定义的 UUIDv7 把 48 位的毫秒时间戳放在最前面,除去版本和变体位,其余的位可以是随机数,也可以放更细的时间或计数器,按字节比较大体随时间递增,存成 BINARY(16) 作主键时新值基本都插入到末尾,规范也建议能用 v7 时不用 v1。JDK 26 起可以用 UUID.ofEpochMillis(System.currentTimeMillis()) 生成,但同一毫秒内的多个值不保证递增,需要严格递增时可以用 uuid-creator 这类带计数器的库,由同一个生成器实例生成的值才保证递增。
号段模式要避免取下一段时卡住发号。美团 Leaf 为每个业务准备两个号段缓冲区,当前号段发出 10% 后就异步把下一段取到另一个缓冲区,当前号段用完时直接切换;下一段还没取回时短暂等待,仍然没有就返回错误。号段长度一般按高峰 QPS 的若干分钟设置,美团建议取 600 倍,即 10 分钟的用量,这样数据库宕机时还能继续发号一段时间。
@@ -710,11 +715,17 @@ public synchronized long nextId() {
用 8 个线程共生成 400 万个 ID,耗时 1.2 秒,全部不重复,每个线程得到的 ID 都是递增的;去掉“序号用完就等到下一毫秒”这一步,400 万个 ID 中只有约 240 万个不重复(JDK 21 实测,见[附录 A2](#a2-雪花算法))。
需要注意的是,同一个实例生成的 ID 是递增的,但不同实例的时钟之间存在偏差,两个实例生成的 ID 只能大致反映生成的先后顺序。
需要注意的是,同一个实例生成的 ID 是递增的,但不同实例的时钟之间存在偏差,两个实例生成的 ID 只能大致反映生成的先后顺序。需要严格递增(下一个 ID 一定大于上一个)时,通常要由一个单点按顺序发号,例如单库的自增,或者同一个键的 INCR(计数不能因故障转移、持久化丢失而回退),吞吐和可用性都受这个单点限制。
号段模式也只是趋势递增,例如两个实例分别领到 1~1000 和 1001~2000,交替取号得到 1、1001、2、1002。
雪花 ID 不重复依赖三个条件:各实例的机器 ID 不同,同一毫秒内的序号不同,时钟不倒退。第二个由加锁的 nextId() 保证;机器 ID 可以在启动时从 ZooKeeper、数据库或配置中心领取。
时钟回拨指的是校时等原因让系统时间倒退。回拨后已经用过的毫秒会再出现一次,序号又从 0 开始,生成的 ID 与之前的相同(模拟见[附录 A2](#a2-雪花算法))。常见的处理:
时钟回拨指的是校时等原因让系统时间倒退。回拨后已经用过的毫秒会再出现一次,序号又从 0 开始,生成的 ID 与之前的相同(模拟见[附录 A2](#a2-雪花算法))。
是否回拨取决于时间同步的方式:直接跳到正确时间时,本机时钟偏快就会往回跳,例如 Ubuntu 24.04 默认的 systemd-timesyncd 偏差达到 0.4 秒就跳变;chrony 按 Ubuntu 的配置(makestep 1 3)只在 chronyd 启动后的前三次时钟更新中、偏差超过 1 秒时跳变,之后只调快或调慢时钟;插入闰秒时内核默认也会把时钟拨回 1 秒。
常见的处理:
- 回拨几毫秒时等时钟追上,例如美团的 Leaf 在 5 ms 以内时等待两倍的差值后重试;
- 回拨较大时报错,摘除这个实例并报警;
@@ -723,7 +734,7 @@ public synchronized long nextId() {
雪花 ID 还有两个容易忽略的问题:
- 它远大于 JavaScript 的安全整数上限 2<sup>53</sup> − 1,前端把它当作数字解析 JSON 时会丢失精度,例如 372990889737342977 解析后变成 372990889737343000,接口中要把 ID 作为字符串返回;
- 并发低时每毫秒只生成一个 ID,序号总是 0,按 ID 对 16 取模分表会全部落到第 0 张表;Leaf 把每个新毫秒的序号初值设为 0~99 的随机数,同样的测试中 16 张表各分到 45~76 个(JDK 21 实测,见[附录 A2](#a2-雪花算法))。
- 并发低时每毫秒只生成一个 ID,序号总是 0,按 ID 对 16 取模时结果只取决于序号的低 4 位,例如每 2 ms 生成一个、共 1000 个 ID,全部落到第 0 张表;Leaf 把每个新毫秒的序号初值设为 0~99 的随机数,同样生成 1000 个 ID 时 16 张表各分到 45~76 个(JDK 21 实测,见[附录 A2](#a2-雪花算法))。
## 九、幂等 🔥🔥
@@ -740,15 +751,15 @@ public synchronized long nextId() {
唯一索引能挡住并发的首次请求:第一个请求的事务还没提交时,同一个键的第二个 INSERT 会等待,第一个提交后它返回 1062,第一个回滚后它插入成功。需要注意的是:
- 1062 之后要查出第一次的结果时,如果同一个事务在 INSERT 之前已经做过普通的 SELECT,可重复读级别下仍沿用之前的快照,查不到这条记录,要用 SELECT ... FOR SHARE 或者新的事务;
- 两个以上的重复请求在等待同一个键时第一个事务回滚,等待者之间可能死锁,其中一个收到 1213,也要当作可以重试的错误(MySQL 8.0 手册中 InnoDB 加锁的例子)。
- 1062 之后要查出第一次的结果时,如果同一个事务在 INSERT 之前已经做过普通的 SELECT,可重复读级别下仍沿用之前的[快照](数据库系统原理.md#快照读与当前读),查不到这条记录,要用 SELECT ... FOR SHARE 或者新的事务;
- 两个以上的重复请求在等待同一个键时第一个事务回滚,等待者之间可能死锁,其中一个收到死锁错误 1213,也要当作可以重试的错误(MySQL 8.0 手册中 InnoDB 加锁的例子)。
去重记录要和业务数据在同一个本地事务中写入,处理失败时一起回滚,重试还能正常执行。如果单独写入去重记录(例如用 Redis 的 SET NX 记下请求 ID),业务失败后要删掉它,否则重试会被挡掉;进程崩溃时来不及删除,所以记录要分两种状态:
- 处理中:期间到达的重复请求返回“处理中”(例如 HTTP 409),让客户端稍后再查;过期时间要长于处理的最长耗时,崩溃后等它过期就能重试;
- 已完成:保存第一次的结果,保留到上游不再重试之后,例如微信支付的回调失败后会在约 24 小时内反复重发。记录中还可以保存请求内容的摘要,同一个幂等键带着不同的内容再次提交时直接报错(Idempotency-Key 首部的 IETF 草案建议返回 422),而不是回放第一次的结果。
- 已完成:保存第一次的结果,保留到上游不再重试之后,例如微信支付的回调失败后会在约 24 小时内反复重发。记录中还可以保存请求内容的摘要,同一个请求 ID 带着不同的内容再次提交时直接报错(Idempotency-Key 首部的 IETF 草案建议返回 422),而不是回放第一次的结果。
业务已经提交、记录还没改为“已完成”时崩溃,重试仍会再执行一次,所以业务写入本身仍要靠唯一约束或状态条件兜底,调用外部服务时让下游按同一个业务键去重。用注解加切面实现时,切面要包在事务的外面,事务提交之后再把记录改为“已完成”;切面在事务里面时,记录改为“已完成”之后事务仍可能回滚,重试就被挡掉了。
业务已经提交、记录还没改为“已完成”时崩溃,重试仍会再执行一次,所以业务写入本身仍要靠唯一约束或状态条件兜底,调用外部服务时让下游按同一个业务键去重。用注解加切面实现时,切面要包在事务的外面(@Transactional 本身也是切面,先后用 @Order 指定,见[动态代理](Spring.md#动态代理)中锁与事务的例子),事务提交之后再把记录改为“已完成”;切面在事务里面时,记录改为“已完成”之后事务仍可能回滚,重试就被挡掉了。
数据库的提交本身也可能结果未知:COMMIT 发出后连接断开,事务可能已经提交,也可能没有,MySQL Connector/J 这时抛出 SQLState 为 08007(Transaction resolution unknown)的异常。重连后要按业务键查询确认,或者让重试本身是幂等的。
@@ -760,7 +771,7 @@ public synchronized long nextId() {
<div align="center"> <img src="pics/idempotent-request-id.png" width="760px"/> </div><br>
没有客户端参与的场景,幂等键用业务上的唯一标识。例如支付回调用支付平台的交易号,再配合上面的状态机:重复的回调影响 0 行时,同样要返回成功,否则支付平台会继续重试。
没有客户端参与的场景,幂等键用业务上的唯一标识。例如支付回调用支付平台的交易号,再配合上面的状态机:重复的回调影响 0 行时,同样要返回成功,否则支付平台会继续重试。条件更新影响 1 行时,才写入发货等后续动作的待发送消息,并与去重记录、状态更新在同一个本地事务中提交(即[本地消息表](#本地消息表)),重复的回调就不会再生成发货消息;消息提交后才转发,转发仍可能重复,接收端还要按业务键去重,见[支付回调与重复支付](系统设计基础.md#支付回调与重复支付)。
分布式锁不能代替幂等。锁只保证同一时刻只有一个请求在处理,第一个请求完成并释放锁之后,重试的请求拿到锁仍会再执行一次。锁的作用是挡住并发的重复请求,减轻数据库的冲突,是否已经处理过还是要靠唯一索引或者状态机判断。
@@ -807,11 +818,13 @@ XXL-JOB 等框架把“什么时候触发”和“执行什么”拆开(以下
调度中心本身也部署多个节点,它们共用一个 MySQL。每轮扫描前先用 SELECT ... FOR UPDATE 锁住 xxl_job_lock 表中的一行,拿到锁的节点才查询 5 秒内到期的任务,并在同一个事务中更新它们的下次触发时间。其它节点等事务提交后才能拿到锁,查到的已经是更新后的时间,所以同一次触发只会被发出一次。
执行器有多个实例时,调度中心按任务的路由策略选择实例:第一个、轮询、一致性哈希、故障转移等策略每次只发给一个实例,分片广播则发给全部实例。需要注意的是,官方文档也提到集群中仍有小概率重复触发,任务本身还是要做到 [幂等](#九幂等)。
查到的任务中,还没到期的按下次触发时间的秒数放进调度中心内存中的时间轮(60 个刻度,每秒一格),由另一个线程每秒取出到期的任务发出调度请求;已经到期、但迟到不超过 5 秒的任务直接触发。下次触发时间已经过去超过 5 秒的任务,例如调度中心停机期间错过的,按调度过期策略处理:默认忽略,也可以设为立即执行一次,两种都从当前时间重新计算下次触发时间,错过多次也最多补一次。
执行器有多个实例时,调度中心按任务的路由策略选择实例:第一个、轮询、[一致性哈希](缓存.md#六一致性哈希)、故障转移(见[失败与宕机](#失败与宕机))等策略每次只发给一个实例,分片广播则发给全部实例。需要注意的是,官方文档也提到集群中仍有小概率重复触发,任务本身还是要做到 [幂等](#九幂等)。
### 分片
只有一个实例执行时,100 万个用户的账单可能要发几个小时。分片指的是把数据按规则分成几份,每个实例只处理其中一份。
只有一个实例执行时,100 万个用户的账单可能要发几个小时,例如每条短信调用外部接口用时 10 ms,串行发送约 2.8 小时。分片指的是把数据按规则分成几份,每个实例只处理其中一份。
XXL-JOB 的分片广播把一次触发发给执行器的每个在线实例,并带上分片序号 index(从 0 开始)和分片总数 total(在线实例数)。任务代码用 XxlJobHelper.getShardIndex() 和 getShardTotal() 取得这两个参数,按 ID 取模只查询自己的那一份:
@@ -836,7 +849,7 @@ total 取的是触发时的在线实例数,扩容后下一次触发自动分
- 执行失败:任务可以配置失败重试次数,调度中心发现执行失败后再触发一次。分片任务只重试失败的那一片,沿用原来的分片参数,例如 0/2;
- 执行中宕机:执行器不会再回调结果,调度中心发现一条调度记录处于“运行中”超过 10 分钟、对应的执行器也已经不在线,就把它标记为失败,再按执行失败处理。
单机的 @Scheduled 没有这些机制,触发时间只保存在进程的内存中,实例停机期间错过的触发不会补执行。
单机的 @Scheduled 没有这些机制,触发时间只保存在进程的内存中,实例停机期间错过的触发不会补执行。需要注意的是,没有配置调度线程池时,所有 @Scheduled 任务共用一个线程(Spring Boot 的 spring.task.scheduling.pool.size 默认为 1),一个任务执行过久,其它任务都会推迟触发;启用虚拟线程后 cron 和 fixedRate 任务各自在新的虚拟线程中执行,fixedDelay 任务仍共用一个线程。
重试的前提是任务可以重复执行。账单任务每发送一个用户就记录下来,例如在账单表的 (user_id, month) 上建唯一索引,重试时跳过已经发送过的用户,做法见 [幂等](#九幂等)。实例 A 发送 2000 条后崩溃,按分片参数 0/2 重试,只补发了剩下的 3000 条,1 万个用户每人一条(见[附录 A6](#a6-分片与按分片重试))。需要注意的是,写记录和发短信不是一个原子操作,两步之间崩溃会漏发或重发一个用户。要做到不漏不重,记录先写成“待发送”,发送成功后再标记完成,做法与 [本地消息表](#本地消息表) 相同,短信服务再按 (user_id, month) 去重。
@@ -851,6 +864,8 @@ total 取的是触发时的在线实例数,扩容后下一次触发自动分
这类场景更适合 [延迟消息](消息队列.md#延迟消息):下单时发送一条 30 分钟后投递的消息,到期只处理这一个订单。实际使用时常把两者结合,延迟消息负责按时关闭,低频的定时扫描兜底,处理消息丢失的订单。超时未支付的订单按 status = 'UNPAID' AND expire_at <= NOW() 扫描,并建 (status, expire_at) 联合索引,每次只读到已经到期的未支付订单,不会扫过大量已完成的历史订单;还要扫描长时间停在关单中的订单,继续关单流程,见[超时关单](系统设计基础.md#超时关单)。
多个实例同时扫描时,可以在事务中用 SELECT ... FOR UPDATE SKIP LOCKED 查询待处理的到期记录,跳过已被其它实例锁住的行,再在同一个事务中把状态改为处理中后提交,正常领取时不会把同一条记录分给两个实例;不加 SKIP LOCKED 时,遇到被锁住的行要等待,直到锁释放或等待超时(MySQL 8.0 实测,见[附录 A8](#a8-skip-locked-领取到期任务))。这种方式适合允许暂时跳过一些记录的任务队列,返回空结果不代表没有到期的记录。实例在处理中崩溃时,记录会停在处理中,要由扫描任务按超时收回;收回后重新执行时,原来的实例可能还没结束,处理逻辑仍要[幂等](#九幂等)。
## 附录:实测
环境为 Apple M1 Pro、macOS,MySQL 8.0.44,JDK 21。
@@ -860,6 +875,7 @@ total 取的是触发时的在线实例数,扩容后下一次触发自动分
每张表插入 100 万行,v 列为 100 个字符:
```sql
set session cte_max_recursion_depth = 1000000;
create table t_auto (id bigint primary key auto_increment, v char(100)) engine=innodb;
create table t_uuid (id char(36) primary key, v char(100)) engine=innodb;
create table t_rand (id char(36) primary key, v char(100)) engine=innodb;
@@ -1067,13 +1083,33 @@ NOWAIT:0.1 ms 返回 (3572, 'Statement aborted because lock(s) could not be ac
持有锁的会话 wait_timeout = 28800:等待方 10.12 s 后返回 (1205, 'Lock wait timeout exceeded; try restarting transaction')
```
### A8 SKIP LOCKED 领取到期任务
表 delay_task(id, biz_key, status, run_at) 在 (status, run_at) 上有联合索引,插入 10 条已到期、1005 条未到期的任务(status = 0 表示待执行)。三个会话按下述顺序在事务中领取任务,查询每次最多返回 4 条:
```sql
SELECT id, biz_key FROM delay_task
WHERE status = 0 AND run_at <= '2026-10-30 12:00:00'
ORDER BY run_at LIMIT 4 FOR UPDATE SKIP LOCKED;
```
第三个会话先去掉 SKIP LOCKED 执行(innodb_lock_wait_timeout 设为 1 秒),回滚后,等前两个会话把领到的任务改为执行中(status = 1)并提交,再加上 SKIP LOCKED 领取。连续运行 3 次,结果相同:
```text
EXPLAIN: type=range key=idx_status_run_at Extra=Using index condition
worker1 ((1, 'order:1000'), (2, 'order:1001'), (3, 'order:1002'), (4, 'order:1003'))
worker2 ((5, 'order:1004'), (6, 'order:1005'), (7, 'order:1006'), (8, 'order:1007'))
worker3 without SKIP LOCKED: 1205 Lock wait timeout exceeded; try restarting transaction 1.01s
worker3 after commit ((9, 'order:1008'), (10, 'order:1009'))
```
## 参考资料
- [Apache Dubbo: Architecture](https://dubbo.apache.org/docs/v2.7/user/preface/architecture/)
- [Apache Dubbo:架构](https://cn.dubbo.apache.org/zh-cn/docsv2.7/user/preface/architecture/)
- [Protocol Buffers: Encoding](https://protobuf.dev/programming-guides/encoding/)
- [gRPC: Core concepts](https://grpc.io/docs/what-is-grpc/core-concepts/)
- [gRPC on HTTP/2](https://grpc.io/blog/grpc-on-http2/)
- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
- 倪超. 从 Paxos 到 ZooKeeper:分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
- [Designing Data-Intensive Applications 中文版](https://github.com/vonng/ddia)
- [Distributed Locks with Redis](https://redis.io/docs/latest/develop/clients/patterns/distributed-locks/)
- [MySQL 8.0: Locking Reads](https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-reads.html)
@@ -1100,8 +1136,8 @@ NOWAIT:0.1 ms 返回 (3572, 'Statement aborted because lock(s) could not be ac
- [Seata Saga 模式](https://seata.apache.org/zh-cn/docs/user/mode/saga/)
- [事务消息 | RocketMQ](https://rocketmq.apache.org/zh/docs/featureBehavior/04transactionmessage/)
- [An Illustrated Proof of the CAP Theorem](https://mwhittaker.github.io/blog/an_illustrated_proof_of_the_cap_theorem/)
- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
- [基于 Zookeeper 的分布式锁](https://web.archive.org/web/20221129202405/http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
- [浅谈分布式锁](https://web.archive.org/web/20250912001324/http://www.linkedkeeper.com/detail/blog.action?bid=1023)
- [基于 Zookeeper 的分布式锁](https://web.archive.org/web/20191223064151/http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
- [聊聊分布式事务,再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
@@ -1111,6 +1147,7 @@ NOWAIT:0.1 ms 返回 (3572, 'Statement aborted because lock(s) could not be ac
- [In Search of an Understandable Consensus Algorithm](https://raft.github.io/raft.pdf)
- [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
- [Leaf——美团点评分布式 ID 生成系统](https://tech.meituan.com/2017/04/21/mt-leaf.html)
- [RFC 9562: Universally Unique IDentifiers (UUIDs)](https://www.rfc-editor.org/rfc/rfc9562)
- [分布式任务调度平台 XXL-JOB](https://www.xuxueli.com/xxl-job/)
- [XXL-JOB 源码:JobScheduleHelper](https://github.com/xuxueli/xxl-job/blob/3.5.0/xxl-job-admin/src/main/java/com/xxl/job/admin/business/scheduler/thread/JobScheduleHelper.java)
- [ShedLock](https://github.com/lukas-krecan/ShedLock)