Merge branch 'master' into patch-1

This commit is contained in:
Feng Ruohang 2020-05-27 21:59:11 +08:00 committed by GitHub
commit df28b7d14a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 126 additions and 125 deletions

3
ch2.md
View File

@ -55,7 +55,7 @@
* 关系模型不能很好地支持一些特殊的查询操作
* 受挫于关系模型的限制性渴望一种更具多动态性与表现力的数据模型【5】
不同的应用程序有不同的需求,一个用例的最佳技术选择可能不同于另一个用例的最佳技术选择。因此,在可预见的未来,关系数据库似乎可能会继续与各种非关系数据库一起使用 - 这种想法有时也被称为**混合持久化polyglot persistence**
不同的应用程序有不同的需求,一个用例的最佳技术选择可能不同于另一个用例的最佳技术选择。因此,在可预见的未来,关系数据库似乎可能会继续与各种非关系数据库一起使用 - 这种想法有时也被称为**混合持久化polyglot persistence**
### 对象关系不匹配
@ -76,6 +76,7 @@
* 第三种选择是将职业教育和联系信息编码为JSON或XML文档将其存储在数据库的文本列中并让应用程序解析其结构和内容。这种配置下通常不能使用数据库来查询该编码列中的值。
对于一个像简历这样自包含文档的数据结构而言JSON表示是非常合适的参见[例2-1]()。JSON比XML更简单。面向文档的数据库如MongoDB 【9】RethinkDB 【10】CouchDB 【11】和Espresso【12】支持这种数据模型。
**例2-1. 用JSON文档表示一个LinkedIn简介**
```json

2
ch3.md
View File

@ -293,7 +293,7 @@ LSM树可以被压缩得更好因此经常比B树在磁盘上产生更小的
B树的一个优点是每个键只存在于索引中的一个位置而日志结构化的存储引擎可能在不同的段中有相同键的多个副本。这个方面使得B树在想要提供强大的事务语义的数据库中很有吸引力在许多关系数据库中事务隔离是通过在键范围上使用锁来实现的在B树索引中这些锁可以直接连接到树【5】。在[第7章](ch7.md)中,我们将更详细地讨论这一点。
B树在数据库体系结构中是非常根深蒂固的为许多工作负载提供始终如一的良好性能所以它们不可能很快就会消失。在新的数据存储中日志结构化索引变得越来越流行。没有快速和容易的规则来确定哪种类型的存储引擎对你的场景更好所以值得进行一些经验上的测试
B树在数据库体系结构中是非常根深蒂固的为许多工作负载提供始终如一的良好性能所以它们不可能很快就会消失。在新的数据存储中日志结构化索引变得越来越流行。没有快速和容易的规则来确定哪种类型的存储引擎对你的场景更好所以值得进行一些经验上的测试
### 其他索引结构

2
ch4.md
View File

@ -380,7 +380,7 @@ Web以这种方式工作客户Web浏览器向Web服务器发出请求
Web浏览器不是唯一的客户端类型。例如在移动设备或桌面计算机上运行的本地应用程序也可以向服务器发出网络请求并且在Web浏览器内运行的客户端JavaScript应用程序可以使用XMLHttpRequest成为HTTP客户端该技术被称为Ajax 【30】。在这种情况下服务器的响应通常不是用于显示给人的HTML而是用于便于客户端应用程序代码如JSON进一步处理的编码数据。尽管HTTP可能被用作传输协议但顶层实现的API是特定于应用程序的客户端和服务器需要就该API的细节达成一致。
此外服务器本身可以是另一个服务的客户端例如典型的Web应用服务器充当数据库的客户端。这种方法通常用于将大型应用程序按照功能区域分解为较小的服务这样当一个服务需要来自另一个服务的某些功能或数据时就会向另一个服务发出请求。这种构建应用程序的方式传统上被称为 **面向服务的体系结构service-oriented architectureSOA** ,最近被改进和更名为 **微服务架构 ** 【31,32】。
此外服务器本身可以是另一个服务的客户端例如典型的Web应用服务器充当数据库的客户端。这种方法通常用于将大型应用程序按照功能区域分解为较小的服务这样当一个服务需要来自另一个服务的某些功能或数据时就会向另一个服务发出请求。这种构建应用程序的方式传统上被称为**面向服务的体系结构service-oriented architectureSOA**,最近被改进和更名为**微服务架构**【31,32】。
在某些方面服务类似于数据库它们通常允许客户端提交和查询数据。但是虽然数据库允许使用我们在第2章 中讨论的查询语言进行任意查询但是服务公开了一个特定于应用程序的API它只允许由服务的业务逻辑应用程序代码预定的输入和输出【33】。这种限制提供了一定程度的封装服务可以对客户可以做什么和不可以做什么施加细粒度的限制。

58
ch5.md
View File

@ -34,7 +34,7 @@
2. 其他副本被称为**追随者followers**,亦称为**只读副本read replicas****从库slaves****备库( sencondaries****热备hot-standby**[^i]。每当领导者将新数据写入本地存储时,它也会将数据变更发送给所有的追随者,称之为**复制日志replication log**记录或**变更流change stream**。每个跟随者从领导者拉取日志,并相应更新其本地数据库副本,方法是按照领导者处理的相同顺序应用所有写入。
3. 当客户想要从数据库中读取数据时,它可以向领导者或追随者查询。 但只有领导者才能接受写操作(从客户端的角度来看从库都是只读的)。
[^i]: 不同的人对 **热hot****温warn** **冷cold** 备份服务器有不同的定义。 例如在PostgreSQL中**热备hot standby**指的是能接受客户端读请求的副本。而**温备warm standby**只是追随领导者,但不处理客户端的任何查询。 就本书而言,这些差异并不重要。
[^i]: 不同的人对**热hot****温warm****冷cold** 备份服务器有不同的定义。 例如在PostgreSQL中**热备hot standby**指的是能接受客户端读请求的副本。而**温备warm standby**只是追随领导者,但不处理客户端的任何查询。 就本书而言,这些差异并不重要。
![](img/fig5-1.png)
**图5-1 基于领导者(主-从)的复制**
@ -62,7 +62,7 @@
通常情况下,基于领导者的复制都配置为完全异步。 在这种情况下,如果主库失效且不可恢复,则任何尚未复制给从库的写入都会丢失。 这意味着即使已经向客户端确认成功,写入也不能保证 **持久Durable** 。 然而,一个完全异步的配置也有优点:即使所有的从库都落后了,主库也可以继续处理写入。
弱化的持久性可能听起来像是一个坏的折衷,无论如何,异步复制已经被广泛使用了,特别当有很多追随者,或追随者异地分布时。 稍后将在“[复制延迟问题](#复制延迟问题)”中回到这个问题。
弱化的持久性可能听起来像是一个坏的折衷,然而异步复制已经被广泛使用了,特别当有很多追随者,或追随者异地分布时。 稍后将在“[复制延迟问题](#复制延迟问题)”中回到这个问题。
> ### 关于复制的研究
>
@ -215,7 +215,7 @@
* 读用户**可能已经修改过**的内容时,都从主库读;这就要求有一些方法,不用实际查询就可以知道用户是否修改了某些东西。举个例子,社交网络上的用户个人资料信息通常只能由用户本人编辑,而不能由其他人编辑。因此一个简单的规则是:从主库读取用户自己的档案,在从库读取其他用户的档案。
* 如果应用中的大部分内容都可能被用户编辑,那这种方法就没用了,因为大部分内容都必须从主库读取(扩容读就没效果了)。在这种情况下可以使用其他标准来决定是否从主库读取。例如可以跟踪上次更新的时间,在上次更新后的一分钟内,从主库读。还可以监控从库的复制延迟,防止任向任何滞后超过一分钟到底从库发出查询。
* 如果应用中的大部分内容都可能被用户编辑,那这种方法就没用了,因为大部分内容都必须从主库读取(扩容读就没效果了)。在这种情况下可以使用其他标准来决定是否从主库读取。例如可以跟踪上次更新的时间,在上次更新后的一分钟内,从主库读。还可以监控从库的复制延迟,防止对任意比主库滞后超过一分钟的从库发出查询。
* 客户端可以记住最近一次写入的时间戳,系统需要确保从库为该用户提供任何查询时,该时间戳前的变更都已经传播到了本从库中。如果当前从库不够新,则可以从另一个从库读,或者等待从库追赶上来。
@ -383,9 +383,9 @@
#### 收敛至一致的状态
单主数据库按顺序应用写操作:如果同一个字段有多个更新,则最后一个写操作将确定该字段的最终值。
单主数据库按顺序进行写操作:如果同一个字段有多个更新,则最后一个写操作将决定该字段的最终值。
在多主配置中,写入顺序没有定义,所以最终值应该是什么并不清楚。在[图5-7](img/fig5-7.png)中在主库1中标题首先更新为B而后更新为C在主库2中首先更新为C然后更新为B。两个顺序都不是“更正确”的。
在多主配置中,没有明确的写入顺序,所以最终值应该是什么并不清楚。在[图5-7](img/fig5-7.png)中在主库1中标题首先更新为B而后更新为C在主库2中首先更新为C然后更新为B。两个顺序都不是“更正确”的。
如果每个副本只是按照它看到写入的顺序写入那么数据库最终将处于不一致的状态最终值将是在主库1的C和主库2的B。这是不可接受的每个复制方案都必须确保数据在所有副本中最终都是相同的。因此数据库必须以一种**收敛convergent**的方式解决冲突,这意味着所有副本必须在所有变更复制完成时收敛至一个相同的最终值。
@ -394,7 +394,7 @@
* 给每个写入一个唯一的ID例如一个时间戳一个长的随机数一个UUID或者一个键和值的哈希挑选最高ID的写入作为胜利者并丢弃其他写入。如果使用时间戳这种技术被称为**最后写入胜利LWW, last write wins**。虽然这种方法很流行但是很容易造成数据丢失【35】。我们将在[本章末尾](#检测并发写入)更详细地讨论LWW。
* 为每个副本分配一个唯一的IDID编号更高的写入具有更高的优先级。这种方法也意味着数据丢失。
* 以某种方式将这些值合并在一起 - 例如,按字母顺序排序,然后连接它们(在[图5-7](img/fig5-7.png)中合并的标题可能类似于“B/C”
* 在保留所有信息的显式数据结构中记录冲突,并编写解决冲突的应用程序代码(也许通过提示用户的方式)。
* 用一种可保留所有信息的显式数据结构来记录冲突,并编写解决冲突的应用程序代码(也许通过提示用户的方式)。
@ -416,7 +416,7 @@
> #### 题外话:自动冲突解决
>
> 冲突解决规则可能很快变得复杂,并且自定义代码可能容易出错。亚马逊是一个经常被引用的例子,由于冲突解决处理程序令人惊讶的效果一段时间以来购物车上的冲突解决逻辑将保留添加到购物车的物品但不包括从购物车中移除的物品。因此顾客有时会看到物品重新出现在他们的购物车中即使他们之前已经被移走【37】。
> 冲突解决规则可能很快变得复杂,并且自定义代码可能容易出错。亚马逊是一个经常被引用的例子,由于冲突解决处理程序令人意外的效果一段时间以来购物车上的冲突解决逻辑将保留添加到购物车的物品但不包括从购物车中移除的物品。因此顾客有时会看到物品重新出现在他们的购物车中即使他们之前已经被移走【37】。
>
> 已经有一些有趣的研究来自动解决由于数据修改引起的冲突。有几行研究值得一提:
>
@ -435,13 +435,13 @@
其他类型的冲突可能更为微妙,难以发现。例如,考虑一个会议室预订系统:它记录谁订了哪个时间段的哪个房间。应用需要确保每个房间只有一组人同时预定(即不得有相同房间的重叠预订)。在这种情况下,如果同时为同一个房间创建两个不同的预订,则可能会发生冲突。即使应用程序在允许用户进行预订之前检查可用性,如果两次预订是由两个不同的领导者进行的,则可能会有冲突。
现在还没有一个现成的答案,但在接下来的章节中,我们将追溯到对这个问题有很好的理解。我们将在第7章中看到更多的冲突示例在[第12章](ch12.md)中我们将讨论用于检测和解决复制系统中冲突的可扩展方法。
现在还没有一个现成的答案,但在接下来的章节中,我们将更好地了解这个问题。我们将在第7章中看到更多的冲突示例在[第12章](ch12.md)中我们将讨论用于检测和解决复制系统中冲突的可扩展方法。
### 多主复制拓扑
复制拓扑描述写入从一个节点传播到另一个节点的通信路径。如果你有两个领导者,如[图5-7]()所示只有一个合理的拓扑结构领导者1必须把他所有的写到领导者2反之亦然。有两个以上的领导各种不同的拓扑是可能的。[图5-8]()举例说明了一些例子。
**复制拓扑**replication topology描述写入从一个节点传播到另一个节点的通信路径。如果你有两个领导者,如[图5-7]()所示只有一个合理的拓扑结构领导者1必须把他所有的写到领导者2反之亦然。有两个以上的领导,各种不同的拓扑是可能的。[图5-8]()举例说明了一些例子。
![](img/fig5-8.png)
@ -451,17 +451,17 @@
[^v]: 不要与星型模式混淆(请参阅“[分析模式:星型还是雪花](ch2.md#分析模式:星型还是雪花)”),其中描述了数据模型的结构,而不是节点之间的通信拓扑。
在圆形和星形拓扑中,写入可能需要在到达所有副本之前通过多个节点。因此,节点需要转发从其他节点收到的数据更改。为了防止无限复制循环,每个节点被赋予一个唯一的标识符,并且在复制日志中,每个写入都被标记了所有已经过的节点的标识符【43】。当一个节点收到用自己的标识符标记的数据更改时该数据更改将被忽略因为节点知道它已经被处理。
在圆形和星形拓扑中写入可能需要在到达所有副本之前通过多个节点。因此节点需要转发从其他节点收到的数据更改。为了防止无限复制循环每个节点被赋予一个唯一的标识符并且在复制日志中每个写入都被标记了所有已经过的节点的标识符【43】。当一个节点收到用自己的标识符标记的数据更改时该数据更改将被忽略因为节点知道它已经被处理
循环和星型拓扑的问题是,如果只有一个节点发生故障,则可能会中断其他节点之间的复制消息流,导致它们无法通信,直到节点修复。拓扑结构可以重新配置为在发生故障的节点上工作,但在大多数部署中,这种重新配置必须手动完成。更密集连接的拓扑结构(例如全部到全部)的容错性更好,因为它允许消息沿着不同的路径传播,避免单点故障。
另一方面,全拓扑也可能有问题。特别是,一些网络链接可能比其他网络链接更快(例如,由于网络拥塞),结果是一些复制消息可能“超过”其他复制消息,如[图5-9](img/fig5-9.png)所示。
另一方面,全部到全部的拓扑也可能有问题。特别是,一些网络链接可能比其他网络链接更快(例如,由于网络拥塞),结果是一些复制消息可能“超过”其他复制消息,如[图5-9](img/fig5-9.png)所示。
![](img/fig5-9.png)
**图5-9 使用多主程序复制时,可能会在某些副本中写入错误的顺序。**
在[图5-9](img/fig5-9.png)中客户端A向**林登万Leader One**的表中插入一行客户端B在主库3上更新该行。然而主库2可以以不同的顺序接收写入它可以首先接收更新其中从它的角度来看是对数据库中不存在的行的更新并且仅在稍后接收到相应的插入其应该在更新之前
在[图5-9](img/fig5-9.png)中客户端A向主库1的表中插入一行客户端B在主库3上更新该行。然而主库2可以以不同的顺序接收写入它可以首先接收更新其中从它的角度来看是对数据库中不存在的行的更新并且仅在稍后接收到相应的插入其应该在更新之前
这是一个因果关系的问题,类似于我们在“[一致前缀读](ch8.md#一致前缀读)”中看到的更新取决于先前的插入所以我们需要确保所有节点先处理插入然后再处理更新。仅仅在每一次写入时添加一个时间戳是不够的因为时钟不可能被充分地同步以便在主库2处正确地排序这些事件见[第8章](ch8.md))。
@ -489,7 +489,7 @@
![](img/fig5-10.png)
**图5-10 仲裁写入,法定读取,并在节点中断后读修复。**
**图5-10 法定写入,法定读取,并在节点中断后读修复。**
现在想象一下,不可用的节点重新联机,客户端开始读取它。节点关闭时发生的任何写入都从该节点丢失。因此,如果您从该节点读取数据,则可能会将陈旧(过时)值视为响应。
@ -503,13 +503,13 @@
***读修复Read repair***
当客户端并行读取多个节点时,它可以检测到任何陈旧的响应。例如,在[图5-10](img/fig5-10.png)中用户2345获得了来自Replica 3的版本6值和来自副本1和2的版本7值。客户端发现副本3具有陈旧值并将新值写回复制品。这种方法适用于频繁阅读的值。
当客户端并行读取多个节点时,它可以检测到任何陈旧的响应。例如,在[图5-10](img/fig5-10.png)中用户2345获得了来自副本3的版本6值和来自副本1和2的版本7值。客户端发现副本3具有陈旧值并将新值写回到该副本。这种方法适用于读频繁的值。
***反熵过程Anti-entropy process***
此外,一些数据存储具有后台进程,该进程不断查找副本之间的数据差异,并将任何缺少的数据从一个副本复制到另一个副本。与基于领导者的复制中的复制日志不同,此反熵过程不会以任何特定的顺序复制写入,并且在复制数据之前可能会有显著的延迟。
并不是所有的系统都实现了这两个;例如Voldemort目前没有反熵过程。请注意如果没有反熵过程某些副本中很少读取的值可能会丢失从而降低了持久性因为只有在应用程序读取值时才执行读修复。
并不是所有的系统都实现了这两个例如Voldemort目前没有反熵过程。请注意如果没有反熵过程某些副本中很少读取的值可能会丢失从而降低了持久性因为只有在应用程序读取值时才执行读修复。
#### 读写的法定人数
@ -517,16 +517,16 @@
如果我们知道,每个成功的写操作意味着在三个副本中至少有两个出现,这意味着至多有一个副本可能是陈旧的。因此,如果我们从至少两个副本读取,我们可以确定至少有一个是最新的。如果第三个副本停机或响应速度缓慢,则读取仍可以继续返回最新值。
更一般地说如果有n个副本每个写入必须由w节点确认才能被认为是成功的并且我们必须至少为每个读取查询r个节点。 (在我们的例子中,$n = 3w = 2r = 2$)。只要$w + r> n$我们期望在读取时获得最新的值因为r个读取中至少有一个节点是最新的。遵循这些r值w值的读写称为**法定人数quorum**[^vii]的读和写。【44】 你可以认为r和w是有效读写所需的最低票数。
更一般地说如果有n个副本每个写入必须由w节点确认才能被认为是成功的并且我们必须至少为每个读取查询r个节点。 (在我们的例子中,$n = 3w = 2r = 2$)。只要$w + r> n$我们期望在读取时获得最新的值因为r个读取中至少有一个节点是最新的。遵循这些r值w值的读写称为**法定人数quorum**[^vii]的读和写【44】。你可以认为r和w是有效读写所需的最低票数。
[^vii]: 有时候这种法定人数被称为严格的法定人数,相对“松散的法定人数”而言(见“[松散法定人数与带提示的接力](#松散法定人数与带提示的接力)”)
[^vii]: 有时候这种法定人数被称为严格的法定人数,相对“宽松的法定人数”而言(见“[宽松的法定人数与提示移交](#宽松的法定人数与提示移交)”)
在Dynamo风格的数据库中参数nw和r通常是可配置的。一个常见的选择是使n为奇数通常为3或5并设置 $w = r =n + 1/ 2$(向上取整)。但是可以根据需要更改数字。例如,设置$w = n$和$r = 1$的写入很少且读取次数较多的工作负载可能会受益。这使得读取速度更快,但具有只有一个失败节点导致所有数据库写入失败的缺点。
> 集群中可能有多于n的节点。集群的机器数可能多于副本数目但是任何给定的值只能存储在n个节点上。 这允许对数据集进行分区,从而支持可以放在一个节点上的数据集更大的数据集。 将在第6章回到分区。
>
仲裁条件$w + r> n$允许系统容忍不可用的节点,如下所示:
法定人数条件$w + r> n$允许系统容忍不可用的节点,如下所示:
* 如果$w <n$如果节点不可用我们仍然可以处理写入
* 如果$r <n$如果节点不可用我们仍然可以处理读取
@ -542,7 +542,7 @@
### 仲裁一致性的局限性
### 法定人数一致性的局限性
如果你有n个副本并且你选择w和r使得$w + r> n$,你通常可以期望每个读取返回为一个键写的最近的值。情况就是这样,因为你写的节点集合和你读过的节点集合必须重叠。也就是说,您读取的节点中必须至少有一个具有最新值的节点(如[图5-11](img/fig5-11.png)所示)。
@ -554,12 +554,12 @@
但是,即使在$w + r> n$的情况下,也可能存在返回陈旧值的边缘情况。这取决于实现,但可能的情况包括:
* 如果使用松散的法定人数(见“[松散法定人数与带提示的接力](#松散法定人数与带提示的接力)”w个写入和r个读取落在完全不同的节点上因此r节点和w之间不再保证有重叠节点【46】。
* 如果两个写入同时发生不清楚哪一个先发生。在这种情况下唯一安全的解决方案是合并并发写入请参阅第171页的“处理写入冲突”。如果根据时间戳最后写入胜利挑选出胜者则由于时钟偏差[35],写入可能会丢失。我们将返回“[检测并发写入](#检测并发写入)”中的此主题。
* 如果使用宽松的法定人数(见“[宽松的法定人数与提示移交](#宽松的法定人数与提示移交)”w个写入和r个读取落在完全不同的节点上因此r节点和w之间不再保证有重叠节点【46】。
* 如果两个写入同时发生不清楚哪一个先发生。在这种情况下唯一安全的解决方案是合并并发写入请参阅第171页的“处理写入冲突”。如果根据时间戳最后写入胜利挑选出一个胜者,则由于时钟偏差[35],写入可能会丢失。我们将返回“[检测并发写入](#检测并发写入)”中的此主题。
* 如果写操作与读操作同时发生,写操作可能仅反映在某些副本上。在这种情况下,不确定读取是返回旧值还是新值。
* 如果写操作在某些副本上成功而在其他节点上失败例如因为某些节点上的磁盘已满在小于w个副本上写入成功。所以整体判定写入失败但整体写入失败并没有在写入成功的副本上回滚。这意味着如果一个写入虽然报告失败后续的读取仍然可能会读取这次失败写入的值【47】。
* 如果携带新值的节点失败需要读取其他带有旧值的副本。并且其数据从带有旧值的副本中恢复则存储新值的副本数可能会低于w从而打破法定人数条件。
* 即使一切工作正常,有时也会不幸地出现关于**时序timing**的边缘情况,在这种情况下,您可能会感到不安,因为我们将在第334页上的“[线性化和法定人数](ch9.md#线性化和法定人数)”中看到。
* 即使一切工作正常,有时也会不幸地出现关于**时序timing**的边缘情况我们将在第334页上的“[线性化和法定人数](ch9.md#线性化和法定人数)”中看到这点
因此,尽管法定人数似乎保证读取返回最新的写入值,但在实践中并不那么简单。 Dynamo风格的数据库通常针对可以忍受最终一致性的用例进行优化。允许通过参数w和r来调整读取陈旧值的概率但把它们当成绝对的保证是不明智的。
@ -575,7 +575,7 @@
已经有一些关于衡量无主复制数据库中的复制陈旧度的研究并根据参数nw和r来预测陈旧读取的预期百分比【48】。不幸的是这还不是很常见的做法但是将过时测量值包含在数据库的标准度量标准中是一件好事。最终的一致性是故意模糊的保证但是对于可操作性来说能够量化“最终”是很重要的。
### 松散法定人数与带提示的接力
### 宽松的法定人数与提示移交
合理配置的法定人数可以使数据库无需故障切换即可容忍个别节点的故障。也可以容忍个别节点变慢因为请求不必等待所有n个节点响应——当w或r节点响应时它们可以返回。对于需要高可用、低延时、且能够容忍偶尔读到陈旧值的应用场景来说这些特性使无主复制的数据库很有吸引力。
@ -586,15 +586,15 @@
* 将错误返回给我们无法达到w或r节点的法定数量的所有请求是否更好
* 或者我们是否应该接受写入然后将它们写入一些可达的节点但不在n值通常存在的n个节点之间
后者被认为是一个**松的法定人数sloppy quorum**【37】写和读仍然需要w和r成功的响应但是那些可能包括不在指定的n个“主”节点中的值。比方说如果你把自己锁在房子外面你可能会敲开邻居的门问你是否可以暂时停留在沙发上。
后者被认为是一个**松的法定人数sloppy quorum**【37】写和读仍然需要w和r成功的响应但是那些可能包括不在指定的n个“主”节点中的值。比方说如果你把自己锁在房子外面你可能会敲开邻居的门问你是否可以暂时停留在沙发上。
一旦网络中断得到解决,代表另一个节点临时接受的一个节点的任何写入都被发送到适当的“本地”节点。这就是所谓的**带提示的接力hinted handoff**。 (一旦你再次找到你的房子的钥匙,你的邻居礼貌地要求你离开沙发回家。)
一旦网络中断得到解决,代表另一个节点临时接受的一个节点的任何写入都被发送到适当的“本地”节点。这就是所谓的**提示移交hinted handoff**。 (一旦你再次找到你的房子的钥匙,你的邻居礼貌地要求你离开沙发回家。)
松散法定人数对写入可用性的提高特别有用只要有任何w节点可用数据库就可以接受写入。然而这意味着即使当$w + r> n$时也不能确定读取某个键的最新值因为最新的值可能已经临时写入了n之外的某些节点【47】。
宽松的法定人数对写入可用性的提高特别有用只要有任何w节点可用数据库就可以接受写入。然而这意味着即使当$w + r> n$时也不能确定读取某个键的最新值因为最新的值可能已经临时写入了n之外的某些节点【47】。
因此,在传统意义上,一个松的法定人数实际上不是一个法定人数。这只是一个保证即数据存储在w节点的地方。不能保证r节点的读取直到提示已经完成。
因此,在传统意义上,一个松的法定人数实际上不是一个法定人数。这只是一个保证即数据存储在w节点的地方。不能保证r节点的读取直到提示已经完成。
在所有常见的Dynamo实现中松散法定人数是可选的。在Riak中它们默认是启用的而在Cassandra和Voldemort中它们默认是禁用的【46,49,50】。
在所有常见的Dynamo实现中宽松的法定人数是可选的。在Riak中它们默认是启用的而在Cassandra和Voldemort中它们默认是禁用的【46,49,50】。
#### 运维多个数据中心
@ -606,7 +606,7 @@
### 检测并发写入
Dynamo风格的数据库允许多个客户端同时写入相同的Key这意味着即使使用严格的法定人数也会发生冲突。这种情况与多领导者复制相似参阅“[处理写入冲突](#处理写入冲突)”但在Dynamo样式的数据库中在**读修复**或**带提示的接力**期间也可能会产生冲突。
Dynamo风格的数据库允许多个客户端同时写入相同的Key这意味着即使使用严格的法定人数也会发生冲突。这种情况与多领导者复制相似参阅“[处理写入冲突](#处理写入冲突)”但在Dynamo样式的数据库中在**读修复**或**提示移交**期间也可能会产生冲突。
问题在于,由于可变的网络延迟和部分故障,事件可能在不同的节点以不同的顺序到达。例如,[图5-12](img/fig5-12.png)显示了两个客户机A和B同时写入三节点数据存储区中的键X

14
ch6.md
View File

@ -107,7 +107,7 @@
如今大多数数据系统无法自动补偿这种高度偏斜的负载因此应用程序有责任减少偏斜。例如如果一个主键被认为是非常火爆的一个简单的方法是在主键的开始或结尾添加一个随机数。只要一个两位数的十进制随机数就可以将主键分散为100种不同的主键,从而存储在不同的分区中。
然而将主键进行分割之后任何读取都必须要做额外的工作因为他们必须从所有100个主键分布中读取数据并将其合并。此技术还需要额外的记录只需要对少量热点附加随机数;对于写入吞吐量低的绝大多数主键来是不必要的开销。因此,您还需要一些方法来跟踪哪些键需要被分割。
然而将主键进行分割之后任何读取都必须要做额外的工作因为他们必须从所有100个主键分布中读取数据并将其合并。此技术还需要额外的记录只需要对少量热点附加随机数;对于写入吞吐量低的绝大多数主键来是不必要的开销。因此,您还需要一些方法来跟踪哪些键需要被分割。
也许在将来,数据系统将能够自动检测和补偿偏斜的工作负载;但现在,您需要自己来权衡。
@ -123,7 +123,7 @@
次级索引的问题是它们不能整齐地映射到分区。有两种用二级索引对数据库进行分区的方法:**基于文档的分区document-based**和**基于关键词term-based的分区**。
### 按文档的二级索引
### 基于文档的二级索引进行分区
假设你正在经营一个销售二手车的网站(如[图6-4](img/fig6-4.png)所示)。 每个列表都有一个唯一的ID——称之为文档ID——并且用文档ID对数据库进行分区例如分区0中的ID 0到499分区1中的ID 500到999等
@ -133,7 +133,7 @@
![](img/fig6-4.png)
**图6-4 按文档分区二级索引**
**图6-4 基于文档的二级索引进行分区**
在这种索引方法中每个分区是完全独立的每个分区维护自己的二级索引仅覆盖该分区中的文档。它不关心存储在其他分区的数据。无论何时您需要写入数据库添加删除或更新文档只需处理包含您正在编写的文档ID的分区即可。出于这个原因**文档分区索引**也被称为**本地索引local index**(而不是将在下一节中描述的**全局索引global index**)。
@ -143,7 +143,7 @@
这种查询分区数据库的方法有时被称为**分散/聚集scatter/gather**,并且可能会使二级索引上的读取查询相当昂贵。即使并行查询分区,分散/聚集也容易导致尾部延迟放大(参阅“[实践中的百分位点](ch1.md#实践中的百分位点)”。然而它被广泛使用MongoDBRiak 【15】Cassandra 【16】Elasticsearch 【17】SolrCloud 【18】和VoltDB 【19】都使用文档分区二级索引。大多数数据库供应商建议您构建一个能从单个分区提供二级索引查询的分区方案但这并不总是可行尤其是当在单个查询中使用多个二级索引时例如同时需要按颜色和制造商查询
### 根据关键词(Term)的二级索引
### 基于关键词(Term)的二级索引进行分区
我们可以构建一个覆盖所有分区数据的**全局索引**,而不是给每个分区创建自己的次级索引(本地索引)。但是,我们不能只把这个索引存储在一个节点上,因为它可能会成为瓶颈,违背了分区的目的。全局索引也必须进行分区,但可以采用与主键不同的分区方式。
@ -151,7 +151,7 @@
![](img/fig6-5.png)
**图6-5 关键词对二级索引进行分区**
**图6-5 基于关键词对二级索引进行分区**
我们将这种索引称为**关键词分区term-partitioned**,因为我们寻找的关键词决定了索引的分区方式。例如,一个关键词可能是:`颜色:红色`。**关键词(Term)** 来源于来自全文搜索索引(一种特殊的次级索引),指文档中出现的所有单词。
@ -316,8 +316,8 @@
我们还讨论了分区和二级索引之间的相互作用。次级索引也需要分区,有两种方法:
* 文档分区(本地索引),其中二级索引存储在与主键和值相同的分区中。这意味着只有一个分区需要在写入时更新,但是读取二级索引需要在所有分区之间进行分散/收集。
* 关键词分区(全局索引),其中二级索引存在不同的分区中。辅助索引中的条目可以包括来自主键的所有分区的记录。当文档写入时,需要更新多个分区中的二级索引;但是可以从单个分区中进行读取。
* 基于文档分区(本地索引),其中二级索引存储在与主键和值相同的分区中。这意味着只有一个分区需要在写入时更新,但是读取二级索引需要在所有分区之间进行分散/收集。
* 基于关键词分区(全局索引),其中二级索引存在不同的分区中。辅助索引中的条目可以包括来自主键的所有分区的记录。当文档写入时,需要更新多个分区中的二级索引;但是可以从单个分区中进行读取。
最后,我们讨论了将查询路由到适当的分区的技术,从简单的分区负载平衡到复杂的并行查询执行引擎。

50
ch7.md
View File

@ -23,7 +23,7 @@
数十年来,**事务transaction** 一直是简化这些问题的首选机制。事务是应用程序将多个读写操作组合成一个逻辑单元的一种方式。从概念上讲,事务中的所有读写操作被视作单个操作来执行:整个事务要么成功(**提交commit**)要么失败(**中止abort****回滚rollback**)。如果失败,应用程序可以安全地重试。对于事务来说,应用程序的错误处理变得简单多了,因为它不用再担心部分失败的情况了,即某些操作成功,某些失败(无论出于何种原因)。
和事务打交道时间长了,你可能会觉得它显而易见。但我们不应将其视为理所当然。事务不自然法;它们是为了**简化应用编程模型**而创建的。通过使用事务,应用程序可以自由地忽略某些潜在的错误情况和并发问题,因为数据库会替应用处理好这些。(我们称之为**安全保证safety guarantees**)。
和事务打交道时间长了,你可能会觉得它显而易见。但我们不应将其视为理所当然。事务不是天然存在的;它们是为了**简化应用编程模型**而创建的。通过使用事务,应用程序可以自由地忽略某些潜在的错误情况和并发问题,因为数据库会替应用处理好这些。(我们称之为**安全保证safety guarantees**)。
并不是所有的应用都需要事务,有时候弱化事务保证、或完全放弃事务也是有好处的(例如,为了获得更高性能或更高可用性)。一些安全属性也可以在没有事务的情况下实现。
@ -49,7 +49,7 @@
事务所提供的安全保证通常由众所周知的首字母缩略词ACID来描述ACID代表**原子性Atomicity****一致性Consistency****隔离性Isolation**和**持久性Durability**。它由TheoHärder和Andreas Reuter于1983年创建旨在为数据库中的容错机制建立精确的术语。
但实际上不同数据库的ACID实现并不相同。例如我们将会看到围绕着**隔离性Isolation** 的含义有许多含糊不清【8】。高层次上的想法是合理的但魔鬼隐藏在细节里。今天当一个系统声称自己“符合ACID”时实际上能期待的是什么保证并不清楚。不幸的是ACID现在几乎已经变成了一个营销术语。
但实际上不同数据库的ACID实现并不相同。例如我们将会看到关于**隔离性Isolation** 的含义就有许多含糊不清【8】。高层次上的想法很美好但魔鬼隐藏在细节里。今天当一个系统声称自己“符合ACID”时实际上能期待的是什么保证并不清楚。不幸的是ACID现在几乎已经变成了一个营销术语。
不符合ACID标准的系统有时被称为BASE它代表**基本可用性Basically Available****软状态Soft State**和**最终一致性Eventual consistency**【9】这比ACID的定义更加模糊似乎BASE的唯一合理的定义是“不是ACID”即它几乎可以代表任何你想要的东西。
@ -57,11 +57,11 @@
#### 原子性Atomicity
一般来说,原子是指不能分解成小部分的东西。这个词在计算的不同分支中意味着相似但又微妙不同的东西。例如,在多线程编程中,如果一个线程执行一个原子操作,这意味着另一个线程无法看到该操作的一半结果。系统只能处于操作之前或操作之后的状态,而不是介于两者之间的状态。
一般来说,原子是指不能分解成小部分的东西。这个词在计算机的不同领域中意味着相似但又微妙不同的东西。例如,在多线程编程中,如果一个线程执行一个原子操作,这意味着另一个线程无法看到该操作的一半结果。系统只能处于操作之前或操作之后的状态,而不是介于两者之间的状态。
相比之下ACID的原子性并**不**是关于**并发concurrent**的。它并不是在描述如果几个进程试图同时访问相同的数据会发生什么情况,这种情况包含在缩写***I*** 中,即[**隔离性Isolation**](#隔离性Isolation)
相比之下ACID的原子性并**不**是关于**并发concurrent**的。它并不是在描述如果几个进程试图同时访问相同的数据会发生什么情况,这种情况包含在缩写 ***I*** 中,即[**隔离性Isolation**](#隔离性Isolation)
ACID的原子性描述了当客户想进行多次写入,但在一些写操作处理完之后出现故障的情况。例如进程崩溃,网络连接中断,磁盘变满或者某种完整性约束被违反。如果这些写操作被分组到一个原子事务中,并且该事务由于错误而不能完成(提交),则该事务将被中止,并且数据库必须丢弃或撤消该事务中迄今为止所做的任何写入。
ACID的原子性而是描述了当客户想进行多次写入,但在一些写操作处理完之后出现故障的情况。例如进程崩溃,网络连接中断,磁盘变满或者某种完整性约束被违反。如果这些写操作被分组到一个原子事务中,并且该事务由于错误而不能完成(提交),则该事务将被中止,并且数据库必须丢弃或撤消该事务中迄今为止所做的任何写入。
如果没有原子性,在多处更改进行到一半时发生错误,很难知道哪些更改已经生效,哪些没有生效。该应用程序可以再试一次,但冒着进行两次相同变更的风险,可能会导致数据重复或错误的数据。原子性简化了这个问题:如果事务被**中止abort**,应用程序可以确定它没有改变任何东西,所以可以安全地重试。
@ -69,7 +69,7 @@ ACID原子性的定义特征是**能够在错误时中止事务,丢弃该
#### 一致性Consistency
一致性这个词重载的很厉害
一致性这个词被赋予太多含义
* 在[第5章](ch5.md)中,我们讨论了副本一致性,以及异步复制系统中的最终一致性问题(参阅“[复制延迟问题](ch5.md#复制延迟问题)”)。
* [一致性散列Consistency Hash](ch6.md#一致性散列))是某些系统用于重新分区的一种分区方法。
@ -78,7 +78,7 @@ ACID原子性的定义特征是**能够在错误时中止事务,丢弃该
很不幸,这一个词就至少有四种不同的含义。
ACID一致性的概念是**对数据的一组特定陈述必须始终成立**。即**不变量invariants**。例如,在会计系统中,所有账户整体上必须借贷相抵。如果一个事务开始于一个满足这些不变量的有效数据库,且在事务处理期间的任何写入操作都保持这种有效性,那么可以确定,不变量总是满足的。
ACID一致性的概念是**对数据的一组特定约束必须始终成立**。即**不变量invariants**。例如,在会计系统中,所有账户整体上必须借贷相抵。如果一个事务开始于一个满足这些不变量的有效数据库,且在事务处理期间的任何写入操作都保持这种有效性,那么可以确定,不变量总是满足的。
但是,一致性的这种概念取决于应用程序对不变量的观念,应用程序负责正确定义它的事务,并保持一致性。这并不是数据库可以保证的事情:如果你写入违反不变量的脏数据,数据库也无法阻止你。 (一些特定类型的不变量可以由数据库检查,例如外键约束或唯一约束,但是一般来说,是应用程序来定义什么样的数据是有效的,什么样是无效的。—— 数据库只管存储。)
@ -163,7 +163,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
[^iii]: 这并不完美。如果TCP连接中断则事务必须中止。如果中断发生在客户端请求提交之后但在服务器确认提交发生之前客户端并不知道事务是否已提交。为了解决这个问题事务管理器可以通过一个唯一事务标识符来对操作进行分组这个标识符并未绑定到特定TCP连接。后续再“[数据库端到端的争论](ch12.md#数据库端到端的争论)”一节将回到这个主题。
另一方面许多非关系数据库并没有将这些操作组合在一起的方法。即使存在多对象API例如键值存储可能具有在一个操作中更新几个键的多重放置操作),但这并不一定意味着它具有事务语义:该命令可能在一些键上成功,在其他的键上失败,使数据库处于部分更新的状态。
另一方面许多非关系数据库并没有将这些操作组合在一起的方法。即使存在多对象API例如键值存储可能具有在一个操作中更新几个键的数个put操作),但这并不一定意味着它具有事务语义:该命令可能在一些键上成功,在其他的键上失败,使数据库处于部分更新的状态。
#### 单对象写入
@ -175,7 +175,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
这些问题非常让人头大,故存储引擎一个几乎普遍的目标是:对单节点上的单个对象(例如键值对)上提供原子性和隔离性。原子性可以通过使用日志来实现崩溃恢复(参阅“[使B树可靠]()”),并且可以使用每个对象上的锁来实现隔离(每次只允许一个线程访问对象) )。
一些数据库也提供更复杂的原子操作,例如自增操作,这样就不再需要像 [图7-1](img/fig7-1.png) 那样的读取-修改-写入序列了。同样流行的是 **[比较和设置CAS, compare-and-set](#比较并设置CAS)** 操作,当值没有并发被其他人修改过时,才允许执行写操作。
一些数据库也提供更复杂的原子操作,例如自增操作,这样就不再需要像 [图7-1](img/fig7-1.png) 那样的读取-修改-写入序列了。同样流行的是 **[比较和设置CAS, compare-and-set](#比较并设置CAS)** 操作,当值没有被其他并发修改过时,才允许执行写操作。
这些单对象操作很有用,因为它们可以防止在多个客户端尝试同时写入同一个对象时丢失更新(参阅“[防止丢失更新](#防止丢失更新)”。但它们不是通常意义上的事务。CAS以及其他单一对象操作被称为“轻量级事务”甚至出于营销目的被称为“ACID”【20,21,22】但是这个术语是误导性的。事务通常被理解为**将多个对象上的多个操作合并为一个执行单元的机制**。[^iv]
@ -189,7 +189,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
有一些场景中,单对象插入,更新和删除是足够的。但是许多其他场景需要协调写入几个不同的对象:
* 在关系数据模型中,一个表中的行通常具有对另一个表中的行的外键引用。 (类似的是,在一个图数据模型中,一个顶点有着到其他顶点的边)。多对象事务使你确信这些引用始终有效:当插入几个相互引用的记录时,外键必须是正确的,最新的,不然数据就没有意义。
* 在关系数据模型中,一个表中的行通常具有对另一个表中的行的外键引用。(类似的是,在一个图数据模型中,一个顶点有着到其他顶点的边)。多对象事务使你确信这些引用始终有效:当插入几个相互引用的记录时,外键必须是正确的,最新的,不然数据就没有意义。
* 在文档数据模型中,需要一起更新的字段通常在同一个文档中,这被视为单个对象——更新单个文档时不需要多对象事务。但是,缺乏连接功能的文档数据库会鼓励非规范化(参阅“[关系型数据库与文档数据库在今日的对比](ch2.md#关系型数据库与文档数据库在今日的对比)”)。当需要更新非规范化的信息时,如 [图7-2](img/fig7-2.png) 所示,需要一次更新多个文档。事务在这种情况下非常有用,可以防止非规范化的数据不同步。
* 在具有二级索引的数据库中(除了纯粹的键值存储以外几乎都有),每次更改值时都需要更新索引。从事务角度来看,这些索引是不同的数据库对象:例如,如果没有事务隔离性,记录可能出现在一个索引中,但没有出现在另一个索引中,因为第二个索引的更新还没有发生。
@ -223,7 +223,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
[^译注i]: 轶事:偶然出现的瞬时错误有时称为***Heisenbug***,而确定性的问题对应地称为***Bohrbugs***
出于这个原因,数据库一直试图通过提供**事务隔离transaction isolation** 来隐藏应用程序开发者的并发问题。从理论上讲,隔离可以通过假装没有并发发生,让你的生活更加轻松:**可序列化serializable** 的隔离等级意味着数据库保证事务的效果连续运行(即一次一个,没有任何并发)是一样的
出于这个原因,数据库一直试图通过提供**事务隔离transaction isolation** 来隐藏应用程序开发者的并发问题。从理论上讲,隔离可以通过假装没有并发发生,让你的生活更加轻松:**可序列化serializable** 的隔离等级意味着数据库保证事务的效果如同连续运行(即一次一个,没有任何并发)。
实际上不幸的是:隔离并没有那么简单。**可序列化** 会有性能损失许多数据库不愿意支付这个代价【8】。因此系统通常使用较弱的隔离级别来防止一部分而不是全部的并发问题。这些隔离级别难以理解并且会导致微妙的错误但是它们仍然在实践中被使用【23】。
@ -284,13 +284,13 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
但是要求读锁的办法在实践中效果并不好。因为一个长时间运行的写入事务会迫使许多只读事务等到这个慢写入事务完成。这会损失只读事务的响应时间,并且不利于可操作性:因为等待锁,应用某个部分的迟缓可能由于连锁效应,导致其他部分出现问题。
出于这个原因,大多数数据库[^vi]使用[图7-4]()的方式防止脏读:对于写入的每个对象,数据库都会记住旧的已提交值,和由当前持有写入锁的事务设置的新值。 当事务正在进行时,任何其他读取对象的事务都会拿到旧值。 只有当新值提交后,事务才会切换到读取新值。
出于这个原因,大多数数据库[^vi]使用[图7-4]()的方式防止脏读:对于写入的每个对象,数据库都会记住旧的已提交值,和由当前持有写入锁的事务设置的新值。当事务正在进行时,任何其他读取对象的事务都会拿到旧值。 只有当新值提交后,事务才会切换到读取新值。
[^vi]: 在撰写本文时,唯一在读已提交隔离级别使用读锁的主流数据库是使用`read_committed_snapshot = off`配置的IBM DB2和Microsoft SQL Server [23,36]。
### 快照隔离和可重复读
如果只从表面上看读已提交隔离级别你就认为它完成了事务所需的一切,那是可以原谅的。它允许**中止**(原子性的要求);它防止读取不完整的事务结果,并排写入的并发写入。事实上这些功能非常有用,比起没有事务的系统来,可以提供更多的保证。
如果只从表面上看读已提交隔离级别你就认为它完成了事务所需的一切,那是可以原谅的。它允许**中止**(原子性的要求);它防止读取不完整的事务结果,并且防止并发写入造成的混合。事实上这些功能非常有用,比起没有事务的系统来,可以提供更多的保证。
但是在使用此隔离级别时,仍然有很多地方可能会产生并发错误。例如[图7-6](img/fig7-6.png)说明了读已提交时可能发生的问题。
@ -346,7 +346,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
当一个事务从数据库中读取时事务ID用于决定它可以看见哪些对象看不见哪些对象。通过仔细定义可见性规则数据库可以向应用程序呈现一致的数据库快照。工作如下
1. 在每次事务开始时,数据库列出当时所有其他(尚未提交或中止)的事务清单,即使之后提交了,这些事务的写入也都会被忽略。
1. 在每次事务开始时,数据库列出当时所有其他(尚未提交或尚未中止)的事务清单,即使之后提交了,这些事务已执行任何写入也都会被忽略。
2. 被中止事务所执行的任何写入都将被忽略。
3. 由具有较晚事务ID在当前事务开始之后开始的的事务所做的任何写入都被忽略而不管这些事务是否已经提交。
4. 所有其他写入,对应用都是可见的。
@ -358,7 +358,7 @@ SELECT COUNT*FROM emails WHERE recipient_id = 2 AND unread_flag = true
- 读事务开始时,创建该对象的事务已经提交。
- 对象未被标记为删除,或如果被标记为删除,请求删除的事务在读事务开始时尚未提交。
长时间运行的事务可能会长时间使用快照,并继续读取(从其他事务的角度来看)早已被覆盖或删除的值。由于从来不更新值,而是每次值改变时创建一个新的版本,数据库可以在提供一致快照的同时只产生很小的额外开销。
长时间运行的事务可能会长时间使用快照,并继续读取(从其他事务的角度来看)早已被覆盖或删除的值。由于从来不原地更新值,而是每次值改变时创建一个新的版本,数据库可以在提供一致快照的同时只产生很小的额外开销。
#### 索引和快照隔离
@ -459,17 +459,17 @@ UPDATE wiki_pages SET content = '新内容'
在复制数据库中(参见[第5章](ch5.md)),防止丢失的更新需要考虑另一个维度:由于在多个节点上存在数据副本,并且在不同节点上的数据可能被并发地修改,因此需要采取一些额外的步骤来防止丢失更新。
锁和CAS操作假定有一个最新的数据副本。但是多主或无主复制的数据库通常允许多个写入并发执行并异步复制到副本上因此无法保证有一份数据的最新副本。所以基于锁或CAS操作的技术不适用于这种情况。 (我们将在“[线性化](ch9.md#线性化)”中更详细地讨论这个问题。)
锁和CAS操作假定有一个最新的数据副本。但是多主或无主复制的数据库通常允许多个写入并发执行,并异步复制到副本上,因此无法保证只有一个最新数据的副本。所以基于锁或CAS操作的技术不适用于这种情况。 (我们将在“[线性化](ch9.md#线性化)”中更详细地讨论这个问题。)
相反,如“[检测并发写入](ch5.md#检测并发写入)”一节所述,这种复制数据库中的一种常见方法是允许并发写入创建多个冲突版本的值(也称为兄弟),并使用应用代码或特殊数据结构在事实发生之后解决和合并这些版本。
原子操作可以在复制的上下文中很好地工作尤其当它们具有可交换性时可以在不同的副本上以不同的顺序应用它们且仍然可以得到相同的结果。例如递增计数器或向集合添加元素是可交换的操作。这是Riak 2.0数据类型背后的思想它可以防止复制副本丢失更新。当不同的客户端同时更新一个值时Riak自动将更新合并在一起以免丢失更新【39】。
另一方面,最后写入为准LWW的冲突解决方法很容易丢失更新如“[最后写入为准(丢弃并发写入)](ch5.md#最后写入为准(丢弃并发写入))”中所述。不幸的是LWW是许多复制数据库中的默认值
另一方面,最后写入胜利LWW的冲突解决方法很容易丢失更新如“[最后写入胜利(丢弃并发写入)](ch5.md#最后写入胜利(丢弃并发写入))”中所述。不幸的是LWW是许多复制数据库中的默认方案
#### 写入偏差与幻读
前面的章节中,我们看到了**脏写**和**丢失更新**,当不同的事务并发地尝试写入相同的对象时,会出现两种竞争条件。为了避免数据损坏,这些竞争条件需要被阻止——既可以由数据库自动执行,也可以通过锁和原子写操作这类手动安全措施来防止。
前面的章节中,我们看到了**脏写**和**丢失更新**,当不同的事务并发地尝试写入相同的对象时,会出现两种竞争条件。为了避免数据损坏,这些竞争条件需要被阻止——既可以由数据库自动执行,也可以通过锁和原子写操作这类手动安全措施来防止。
但是,并发写入间可能发生的竞争条件还没有完。在本节中,我们将看到一些更微妙的冲突例子。
@ -569,7 +569,7 @@ COMMIT;
在医生值班的例子中在步骤3中修改的行是步骤1中返回的行之一所以我们可以通过锁定步骤1 中的行(`SELECT FOR UPDATE`)来使事务安全并避免写入偏差。但是其他四个例子是不同的:它们检查是否**不存在**某些满足条件的行,写入会**添加**一个匹配相同条件的行。如果步骤1中的查询没有返回任何行则`SELECT FOR UPDATE`锁不了任何东西。
这种效应:一个事务中的写入改变另一个事务的搜索查询的结果,被称为**幻读**【3】。快照隔离避免了只读查询中幻读但是在像我们讨论的例子那样的读写事务中影会导致特别棘手的写歪斜情况。
这种效应:一个事务中的写入改变另一个事务的搜索查询的结果,被称为**幻读**【3】。快照隔离避免了只读查询中幻读但是在像我们讨论的例子那样的读写事务中读会导致特别棘手的写入偏差情况。
#### 物化冲突
@ -673,7 +673,7 @@ VoltDB还使用存储过程进行复制但不是将事务的写入结果从
大约30年来在数据库中只有一种广泛使用的序列化算法**两阶段锁定2PLtwo-phase locking** [^xi]
[^xi]: 有时也称为**严格两阶段锁定SS2PL, strict two-phas locking**以便和其他2PL变体区分。
[^xi]: 有时也称为**严格两阶段锁定SS2PL, strict two-phase locking**以便和其他2PL变体区分。
> #### 2PL不是2PC
>
@ -811,9 +811,9 @@ WHERE room_id = 123 AND
在两阶段锁定的上下文中,我们讨论了[索引范围锁]()(请参阅“[索引范围锁]()”),它允许数据库锁定与某个搜索查询匹配的所有行的访问权,例如 `WHERE shift_id = 1234`。可以在这里使用类似的技术除了SSI锁不会阻塞其他事务。
在[图7-11]()中事务42 和43 都在班次1234 查找值班医生。如果在`shift_id`上有索引则数据库可以使用索引项1234 来记录事务42 和43 读取这个数据的事实。 (如果没有索引,这个信息可以在表级别进行跟踪)。这个信息只需要保留一段时间:在一个事务完成(提交或中止)之后,所有的并发事务完成之后,数据库就可以忘记它读取的数据了。
在[图7-11]()中事务42 和43 都在班次1234 查找值班医生。如果在`shift_id`上有索引则数据库可以使用索引项1234 来记录事务42 和43 读取这个数据的事实。 (如果没有索引,这个信息可以在表级别进行跟踪)。这个信息只需要保留一段时间:在一个事务完成(提交或中止),并且所有的并发事务完成之后,数据库就可以忘记它读取的数据了。
当事务写入数据库时,它必须在索引中查找最近曾读取受影响数据的其他事务。这个过程类似于在受影响的键范围上获取写锁,但锁并不会阻塞事务到其他事务完成,而是像一个引线一样只是简单通知其他事务:你们读过的数据可能不是最新的啦。
当事务写入数据库时,它必须在索引中查找最近曾读取受影响数据的其他事务。这个过程类似于在受影响的键范围上获取写锁,但锁并不会阻塞事务指导其他读事务完成,而是像警戒线一样只是简单通知其他事务:你们读过的数据可能不是最新的啦。
在[图7-11]()中事务43 通知事务42 其先前读已过时反之亦然。事务42首先提交并成功尽管事务43 的写影响了42 但因为事务43 尚未提交所以写入尚未生效。然而当事务43 想要提交时来自事务42 的冲突写入已经被提交所以事务43 必须中止。
@ -859,13 +859,13 @@ WHERE room_id = 123 AND
***写偏差***
一个事务读取一些东西,根据它所看到的值作出决定,并将决定写入数据库。但是,写作的时候,决定的前提不再是真实的。只有可序列化的隔离才能防止这种异常。
一个事务读取一些东西,根据它所看到的值作出决定,并将该决定写入数据库。但是,写入时,该决定的前提不再是真实的。只有可序列化的隔离才能防止这种异常。
***幻读***
事务读取符合某些搜索条件的对象。另一个客户端进行写入,影响搜索结果。快照隔离可以防止直接的幻像读取,但是写入歪斜环境中的幻影需要特殊处理,例如索引范围锁定。
事务读取符合某些搜索条件的对象。另一个客户端进行写入,影响搜索结果。快照隔离可以防止直接的幻像读取,但是写入偏差上下文中的幻读需要特殊处理,例如索引范围锁定。
弱隔离级别可以防止这些异常情况,但是让应用程序开发人员手动处理其他应用程序(例如,使用显式锁定)。只有可序列化的隔离才能防范所有这些问题。我们讨论了实现可序列化事务的三种不同方法:
​弱隔离级别可以防止其中一些异常情况,此外让应用程序开发人员手动处理剩余那些(例如,使用显式锁定)。只有可序列化的隔离才能防范所有这些问题。我们讨论了实现可序列化事务的三种不同方法:
***字面意义上的串行执行***

78
ch8.md
View File

@ -22,7 +22,7 @@
[^i]: 除了一个例外:我们将假定故障是非拜占庭式的(参见“[拜占庭故障](#拜占庭故障)”)。
使用分布式系统与在一台计算机上编写软件有着根本的区别,主要的区别在于,有许多新的和令人兴奋的方法可以使事情出错【1,2】。在这一章中我们将了解实践中出现的问题理解我们能够依赖和不可以依赖的东西。
使用分布式系统与在一台计算机上编写软件有着根本的区别,主要的区别在于,有许多新颖和刺激的方法可以使事情出错【1,2】。在这一章中我们将了解实践中出现的问题理解我们能够依赖和不可以依赖的东西。
最后,作为工程师,我们的任务是构建能够完成工作的系统(即满足用户期望的保证),尽管一切都出错了。 在[第9章](ch9.md)中,我们将看看一些可以在分布式系统中提供这种保证的算法的例子。 但首先,在本章中,我们必须了解我们面临的挑战。
@ -66,7 +66,7 @@
* 大型数据中心网络通常基于IP和以太网以闭合拓扑排列以提供更高的二等分带宽【9】。超级计算机通常使用专门的网络拓扑结构例如多维网格和环面 【10】这为具有已知通信模式的HPC工作负载提供了更好的性能。
系统越大,其组件之一就越有可能发生变化。随着时间的推移,破碎的东西得到修复,新的东西被破坏,但是在一个有成千上万个节点的系统中,有理由认为总是有一些东西被破坏【7】。当错误处理策略由简单的放弃组成时一个大的系统最终会花费大量时间从错误中恢复而不是做有用的工作【8】。
* 系统越大,其组件之一就越有可能坏掉。随着时间的推移,坏掉的东西得到修复,新的东西又坏掉,但是在一个有成千上万个节点的系统中,有理由认为总是有一些东西是坏掉的【7】。当错误处理策略由简单的放弃组成时一个大的系统最终会花费大量时间从错误中恢复而不是做有用的工作【8】。
* 如果系统可以容忍发生故障的节点,并继续保持整体工作状态,那么这对于操作和维护非常有用:例如,可以执行滚动升级(参阅[第4章](ch4.md)),一次重新启动一个节点,而服务继续服务用户不中断。在云环境中,如果一台虚拟机运行不佳,可以杀死它并请求一台新的虚拟机(希望新的虚拟机速度更快)。
@ -212,17 +212,17 @@
[^ii]: 除了偶尔的keepalive数据包如果TCP keepalive被启用。
如果数据中心网络和互联网是电路交换网络那么在建立电路时就可以建立一个保证的最大往返时间。但是它们并不是以太网和IP是**分组交换协议**这些协议可以从排队中获得,从而使网络无限延迟。这些协议没有电路的概念。
如果数据中心网络和互联网是电路交换网络那么在建立电路时就可以建立一个保证的最大往返时间。但是它们并不是以太网和IP是**分组交换协议**不得不忍受排队的折磨,及其导致的网络无限延迟。这些协议没有电路的概念。
为什么数据中心网络和互联网使用分组交换?答案是,它们针对**突发流量bursty traffic**进行了优化。一个电路适用于音频或视频通话,在通话期间需要每秒传送相当数量的比特。另一方面,请求网页,发送电子邮件或传输文件没有任何特定的带宽要求——我们只是希望它尽快完成。
如果你想通过电路传输文件,你将不得不猜测一个带宽分配。如果您猜的太低,传输速度会不必要的太慢,导致网络容量不能使用。如果你猜的太高电路就无法建立因为如果无法保证其带宽分配网络不能建立电路。因此使用用于突发数据传输的电路浪费网络容量并且使传输不必要地缓慢。相比之下TCP动态调整数据传输速率以适应可用的网络容量。
如果你想通过电路传输文件,你将不得不猜测一个带宽分配。如果您猜的太低,传输速度会不必要的太慢,导致网络容量闲置。如果你猜的太高电路就无法建立因为如果无法保证其带宽分配网络不能建立电路。因此使用用于突发数据传输的电路浪费网络容量并且使传输不必要地缓慢。相比之下TCP动态调整数据传输速率以适应可用的网络容量。
已经有一些尝试去建立支持电路交换和分组交换的混合网络比如ATM[^iii] InfiniBand有一些相似之处【35】它在链路层实现了端到端的流量控制从而减少了在网络中排队尽管它仍然可能因链路拥塞而受到延迟【36】。通过仔细使用**服务质量quality of service,**QoS数据包的优先级和调度和**准入控制admission control**(限速发送器),可以仿真分组网络上的电路交换,或提供统计上的**有限延迟**【25,32】。
[^iii]: **异步传输模式Asynchronous TransferMode, ATM**在20世纪80年代是以太网的竞争对手【32】但在电话网核心交换机之外并没有得到太多的采用。与自动柜员机也称为自动取款机无关尽管共用一个缩写词。或许在一些平行的世界里互联网是基于像ATM这样的东西因为互联网视频通话可能比我们的更可靠因为它们不会遭受丢包和延迟的包裹。
但是,目前在多租户数据中心和公共云或通过互联网[^iv]进行通信时,此类服务质量尚未启用。当前部署的技术不允许我们对网络的延迟或可靠性作出任何保证:我们必须假设网络拥塞,排队和无限的延迟总是会发生。 因此,超时时间没有“正确”的值——它需要通过实验来确定。
但是,目前在多租户数据中心和公共云或通过互联网[^iv]进行通信时,此类服务质量尚未启用。当前部署的技术不允许我们对网络的延迟或可靠性作出任何保证:我们必须假设网络拥塞,排队和无限的延迟总是会发生。因此,超时时间没有“正确”的值——它需要通过实验来确定。
[^iv]: 互联网服务提供商之间的对等协议和通过**BGP网关协议BGP**建立路由之间的对等协议,与电路交换本身相比,与电路交换更接近。在这个级别上,可以购买专用带宽。但是,互联网路由在网络级别运行,而不是主机之间的单独连接,而且运行时间要长得多。
@ -298,12 +298,12 @@
* NTP同步只能和网络延迟一样好所以当您在拥有可变数据包延迟的拥塞网络上时NTP同步的准确性会受到限制。一个实验表明当通过互联网同步时35毫秒的最小误差是可以实现的尽管偶尔的网络延迟峰值会导致大约一秒的误差。根据配置较大的网络延迟会导致NTP客户端完全放弃。
* 一些NTP服务器错误或配置错误报告时间已经过去了几个小时【43,44】。 NTP客户端非常强大因为他们查询多个服务器并忽略异常值。尽管如此在互联网上陌生人告诉你的时候你的系统的正确性还是值得担忧的。
* 闰秒导致59分钟或61秒长的分钟这混淆了未设计闰秒的系统中的时序假设【45】。闰秒已经使许多大型系统崩溃【38,46】的事实说明了关于时钟的假设是多么容易偷偷溜入系统中。处理闰秒的最佳方法可能是通过在一天中逐渐执行闰秒调整这被称为**拖尾smearing**【47,48】使NTP服务器“撒谎”虽然实际的NTP服务器表现各异【49】。
* 在虚拟机中硬件时钟被虚拟化这对于需要精确计时的应用程序提出了额外的挑战【50】。当一个CPU核心在虚拟机之间共享时每个虚拟机都会暂停几十毫秒另一个虚拟机正在运行。从应用程序的角度来看这种停顿表现为时钟突然向前跳跃【26】。
* 如果您在未完全控制的设备上运行软件(例如,移动设备或嵌入式设备),则可能完全不信任该设备的硬件时钟。一些用户故意将其硬件时钟设置为不正确的日期和时间,例如,为了规避游戏中的时间限制,时钟可能会被设置到很远的过去或将来。
* 在虚拟机中硬件时钟被虚拟化这对于需要精确计时的应用程序提出了额外的挑战【50】。当一个CPU核心在虚拟机之间共享时每个虚拟机都会暂停几十毫秒与此同时另一个虚拟机正在运行。从应用程序的角度来看这种停顿表现为时钟突然向前跳跃【26】。
* 如果您在未完全控制的设备上运行软件(例如,移动设备或嵌入式设备),则可能完全不信任该设备的硬件时钟。一些用户故意将其硬件时钟设置为不正确的日期和时间,例如,为了规避游戏中的时间限制,时钟可能会被设置到很远的过去或将来。
如果你足够关心这件事并投入大量资源就可以达到非常好的时钟精度。例如针对金融机构的欧洲法规草案MiFID II要求所有高频率交易基金在UTC时间100微秒内同步时钟以便调试“闪崩”等市场异常现象并帮助检测市场操纵 【51】。
如果你足够在乎这件事并投入大量资源就可以达到非常好的时钟精度。例如针对金融机构的欧洲法规草案MiFID II要求所有高频率交易基金在UTC时间100微秒内同步时钟以便调试“闪崩”等市场异常现象并帮助检测市场操纵 【51】。
使用GPS接收机精确时间协议PTP【52】以及仔细的部署和监测可以实现这种精确度。然而这需要很多努力和专业知识而且有很多东西都会导致时钟同步错误。如果你的NTP守护进程配置错误或者防火墙阻止了NTP通信由漂移引起的时钟误差可能很快就会变大。
通过GPS接收机精确时间协议PTP【52】以及仔细的部署和监测可以实现这种精确度。然而这需要很多努力和专业知识而且有很多东西都会导致时钟同步错误。如果你的NTP守护进程配置错误或者防火墙阻止了NTP通信由漂移引起的时钟误差可能很快就会变大。
### 依赖同步时钟
@ -311,7 +311,7 @@
本章早些时候,我们讨论了网络丢包和任意延迟包的问题。尽管网络在大多数情况下表现良好,但软件的设计必须假定网络偶尔会出现故障,而软件必须正常处理这些故障。时钟也是如此:尽管大多数时间都工作得很好,但需要准备健壮的软件来处理不正确的时钟。
有一部分问题是不正确的时钟很容易被视而不见。如果一台机器的CPU出现故障或者网络配置错误很可能根本无法工作所以很快就会被注意和修复。另一方面如果它的石英时钟有缺陷或者它的NTP客户端配置错误大部分事情似乎仍然可以正常工作即使它的时钟逐渐偏离现实。如果某个软件依赖于精确同步的时钟那么结果更可能是悄无声息且行踪渺茫数据的数据丢失而不是一次惊天动地的崩溃【53,54】。
有一部分问题是不正确的时钟很容易被视而不见。如果一台机器的CPU出现故障或者网络配置错误很可能根本无法工作所以很快就会被注意和修复。另一方面如果它的石英时钟有缺陷或者它的NTP客户端配置错误大部分事情似乎仍然可以正常工作即使它的时钟逐渐偏离现实。如果某个软件依赖于精确同步的时钟那么结果更可能是悄无声息的,仅有微量的数据丢失而不是一次惊天动地的崩溃【53,54】。
因此,如果你使用需要同步时钟的软件,必须仔细监控所有机器之间的时钟偏移。时钟偏离其他时钟太远的节点应当被宣告死亡,并从集群中移除。这样的监控可以确保你在损失发生之前注意到破损的时钟。
@ -329,29 +329,29 @@
尽管如此,[图8-3](img/fig8-3.png)中的时间戳却无法正确排列事件:写入`x = 1`的时间戳为42.004秒,但写入`x = 2`的时间戳为42.003秒,即使`x = 2`在稍后出现。当节点2接收到这两个事件时会错误地推断出`x = 1`是最近的值,而丢弃写入`x = 2`。效果上表现为客户端B的增量操作会丢失。
这种冲突解决策略被称为**最后写入为准LWW**它在多领导者复制和无领导者数据库如Cassandra 【53】和Riak 【54】中被广泛使用参见“[最后写入为准(丢弃并发写入)](#最后写入为准(丢弃并发写入))”一节。有些实现会在客户端而不是服务器上生成时间戳但这并不能改变LWW的基本问题
这种冲突解决策略被称为**最后写入胜利LWW**它在多领导者复制和无领导者数据库如Cassandra 【53】和Riak 【54】中被广泛使用参见“[最后写入胜利(丢弃并发写入)](#最后写入胜利(丢弃并发写入))”一节。有些实现会在客户端而不是服务器上生成时间戳但这并不能改变LWW的基本问题
* 数据库写入可能会神秘地消失:具有滞后时钟的节点无法用快速时钟覆盖之前由节点写入的值,直到节点之间的时钟偏差过去【54,55】。此方案可能导致一定数量的数据被悄悄丢弃而未向应用报告任何错误。
* 数据库写入可能会神秘地消失:具有滞后时钟的节点无法覆盖之前具有快速时钟的节点写入的值,直到节点之间的时钟偏差消逝【54,55】。此方案可能导致一定数量的数据被悄悄丢弃而未向应用报告任何错误。
* LWW无法区分**高频顺序写入**(在[图8-3](img/fig8-3.png)中客户端B的增量操作**一定**发生在客户端A的写入之后和**真正并发写入**(写入者意识不到其他写入者)。需要额外的因果关系跟踪机制(例如版本向量),以防止因果关系的冲突(请参阅“[检测并发写入](ch5.md#检测并发写入)”)。
* 两个节点可以独立生成具有相同时间戳的写入,特别是在时钟仅具有毫秒分辨率的情况下。为了解决这样的冲突,还需要一个额外的**决胜值tiebreaker**可以简单地是一个大随机数但这种方法也可能会导致违背因果关系【53】。
* 两个节点很可能独立地生成具有相同时间戳的写入,特别是在时钟仅具有毫秒分辨率的情况下。为了解决这样的冲突,还需要一个额外的**决胜值tiebreaker**可以简单地是一个大随机数但这种方法也可能会导致违背因果关系【53】。
因此,尽管通过保留最“最近”的值并放弃其他值来解决冲突是很诱惑人的,但是要注意,“最近”的定义取决于本地的**时钟**这很可能是不正确的。即使用频繁同步的NTP时钟一个数据包也可能在时间戳100毫秒根据发送者的时钟时发送并在时间戳99毫秒根据接收者的时钟处到达——看起来好像数据包在发送之前已经到达这是不可能的。
NTP同步是否能足够准确以至于这种不正确的排序不会发生也许不能因为NTP的同步精度本身受到网络往返时间的限制除了石英钟漂移这类误差源之外。为了进行正确的排序你需要一个比测量对象即网络延迟要精确得多的时钟。
所谓的逻辑时钟【56,57】是基于递增计数器而不是振荡石英晶体对于排序事件来说是更安全的选择请参见“[检测并发写入](ch5.md#检测并发写入)”)。逻辑时钟不测量一天中的时间或经过的秒数,而仅测量事件的相对顺序(无论一个事件发生在另一个事件之前还是之后)。相反,用来测量实际经过时间的**时钟**和**单调钟**也被称为物理时钟。我们将在“[顺序保证](#顺序保证)”中查看更多订购信息
所谓的**逻辑时钟logic clock**【56,57】是基于递增计数器而不是振荡石英晶体对于排序事件来说是更安全的选择请参见“[检测并发写入](ch5.md#检测并发写入)”)。逻辑时钟不测量一天中的时间或经过的秒数,而仅测量事件的相对顺序(无论一个事件发生在另一个事件之前还是之后)。相反,用来测量实际经过时间的**时钟**和**单调钟**也被称为**物理时钟physical clock**。我们将在“[顺序保证](#顺序保证)”中来看顺序问题
#### 时钟读数存在置信区间
您可能能够以微秒或甚至纳秒的分辨率读取机器的时钟。但即使可以得到如此细致的测量结果这并不意味着这个值对于这样的精度实际上是准确的。实际上如前所述即使您每分钟与本地网络上的NTP服务器进行同步很可能也不会像前面提到的那样,在不精确的石英时钟上漂移几毫秒。使用公共互联网上的NTP服务器最好的准确度可能达到几十毫秒而且当网络拥塞时误差可能会超过100毫秒【57】。
您可能能够以微秒或甚至纳秒的精度读取机器的时钟。但即使可以得到如此细致的测量结果,这并不意味着这个值对于这样的精度实际上是准确的。实际上,大概率是不准确的——如前所述即使您每分钟与本地网络上的NTP服务器进行同步几毫秒的时间漂移也很容易在不精确的石英时钟上发生。使用公共互联网上的NTP服务器最好的准确度可能达到几十毫秒而且当网络拥塞时误差可能会超过100毫秒【57】。
因此将时钟读数视为一个时间点是没有意义的——它更像是一段时间范围例如一个系统可能以95的置信度认为当前时间处于本分钟内的第10.3秒和10.5秒之间它可能没法比这更精确了【58】。如果我们只知道±100毫秒的时间那么时间戳中的微秒数字部分基本上是没有意义的。
不确定性界限可以根据你的时间源来计算。如果您的GPS接收器或原子时钟直接连接到您的计算机上预期的错误范围由制造商告。如果从服务器获得时间则不确定性取决于自上次与服务器同步以来的石英钟漂移的期望值加上NTP服务器的不确定性再加上到服务器的网络往返时间只是获取粗略近似值并假设服务器是可信的
不确定性界限可以根据你的时间源来计算。如果您的GPS接收器或原子时钟直接连接到您的计算机上预期的错误范围由制造商告。如果从服务器获得时间则不确定性取决于自上次与服务器同步以来的石英钟漂移的期望值加上NTP服务器的不确定性再加上到服务器的网络往返时间只是获取粗略近似值并假设服务器是可信的
不幸的是,大多数系统不公开这种不确定性:例如,当调用`clock_gettime()`时返回值不会告诉你时间戳的预期错误所以你不知道其置信区间是5毫秒还是5年。
一个有趣的例外是Spanner中的Google TrueTime API 【41】它明确地报告了本地时钟的置信区间。当你询问当前时间时你会得到两个值[最早,最晚],这是最早可能的时间戳和最晚可能的时间戳。在不确定性估计的基础上,时钟知道当前的实际时间落在该区间内。间的宽度取决于自从本地石英钟最后与更精确的时钟源同步以来已经过了多长时间。
一个有趣的例外是Spanner中的Google TrueTime API 【41】它明确地报告了本地时钟的置信区间。当你询问当前时间时你会得到两个值[最早,最晚],这是最早可能的时间戳和最晚可能的时间戳。在不确定性估计的基础上,时钟知道当前的实际时间落在该区间内。间的宽度取决于自从本地石英钟最后与更精确的时钟源同步以来已经过了多长时间。
#### 全局快照的同步时钟
@ -359,15 +359,15 @@
快照隔离最常见的实现需要单调递增的事务ID。如果写入比快照晚写入具有比快照更大的事务ID则该写入对于快照事务是不可见的。在单节点数据库上一个简单的计数器就足以生成事务ID。
但是当数据库分布在许多机器上也许可能在多个数据中心中时由于需要协调跨所有分区全局单调递增的事务ID可能很难生成。事务ID必须反映因果关系如果事务B读取由事务A写入的值则B必须具有比A更大的事务ID否则快照就无法保持一致。在有大量的小规模、高频率的事务情景下在分布式系统中创建事务ID成为一个站不住脚的瓶颈[^vi]。
但是当数据库分布在许多机器上也许可能在多个数据中心中时由于需要协调跨所有分区全局单调递增的事务ID很难生成。事务ID必须反映因果关系如果事务B读取由事务A写入的值则B必须具有比A更大的事务ID否则快照就无法保持一致。在有大量的小规模、高频率的事务情景下在分布式系统中创建事务ID成为一个难以防守的瓶颈[^vi]。
[^vi]: 存在分布式序列号生成器例如Twitter的雪花Snowflake其以可扩展的方式例如通过将ID空间的块分配给不同节点近似单调地增加唯一ID。但是它们通常无法保证与因果关系一致的排序因为分配的ID块的时间范围比数据库读取和写入的时间范围要长。另请参阅“[顺序保证](#顺序保证)”。
我们可以使用同步时钟的时间戳作为事务ID吗如果我们能够获得足够好的同步性那么这种方法将具有很合适的属性更晚的事务会有更大的时间戳。当然问题在于时钟精度的不确定性。
Spanner以这种方式实现跨数据中心的快照隔离【5960】。它使用TrueTime API报告的时钟置信区间并基于以下观察结果如果您有两个置信区间每个置信区间包含最早和最可能的时间戳( $A = [A_{earliest}, A_{latest}]$ $B=[B_{earliest}, B_{latest}] $),这两个区间不重叠(即:$A_{earliest} < A_{latest} < B_{earliest} < B_{latest}$那么B肯定发生在A之后这是毫无疑问的只有当区间重叠时我们才不确定A和B发生的顺序
Spanner以这种方式实现跨数据中心的快照隔离【5960】。它使用TrueTime API报告的时钟置信区间并基于以下观察结果如果您有两个置信区间每个置信区间包含最早和最可能的时间戳( $A = [A_{earliest}, A_{latest}]$ $B=[B_{earliest}, B_{latest}]$),这两个区间不重叠(即:$A_{earliest} < A_{latest} < B_{earliest} < B_{latest}$的话那么B肯定发生在A之后这是毫无疑问的只有当区间重叠时我们才不确定A和B发生的顺序
为了确保事务时间戳反映因果关系在提交读写事务之前Spanner在提交读写事务时会故意等待置信区间长度的时间。通过这样它可以确保任何可能读取数据的事务处于足够晚的时间因此它们的置信区间不会重叠。为了保持尽可能短的等待时间Spanner需要保持尽可能小的时钟不确定性为此Google在每个数据中心都部署了一个GPS接收器或原子钟允许时钟在大约7毫秒内同步【41】。
为了确保事务时间戳反映因果关系在提交读写事务之前Spanner在提交读写事务时会故意等待置信区间长度的时间。通过这样它可以确保任何可能读取数据的事务处于足够晚的时间因此它们的置信区间不会重叠。为了保持尽可能短的等待时间Spanner需要保持尽可能小的时钟不确定性为此Google在每个数据中心都部署了一个GPS接收器或原子钟允许时钟在大约7毫秒内同步【41】。
对分布式事务语义使用时钟同步是一个活跃的研究领域【57,61,62】。这些想法很有趣但是它们还没有在谷歌之外的主流数据库中实现。
@ -375,7 +375,7 @@
让我们考虑在分布式系统中使用危险时钟的另一个例子。假设你有一个数据库,每个分区只有一个领导者。只有领导被允许接受写入。一个节点如何知道它仍然是领导者(它并没有被别人宣告为死亡),并且它可以安全地接受写入?
一种选择是领导者从其他节点获得一个**租约lease**类似一个带超时的锁【63】。任一时刻只有一个节点可以持有租约——因此当一个节点获得一个租约时它知道它在某段时间内自己是领导者直到租约到期。为了保持领导地位节点必须周期性地在租约过期前续期。
一种选择是领导者从其他节点获得一个**租约lease**类似一个带超时的锁【63】。任一时刻只有一个节点可以持有租约——因此当一个节点获得一个租约时它知道它在某段时间内自己是领导者直到租约到期。为了保持领导地位节点必须周期性地在租约过期前续期。
如果节点发生故障,就会停止续期,所以当租约过期时,另一个节点可以接管。
@ -403,7 +403,7 @@ while(true){
假设一个线程可能会暂停很长时间,这是疯了吗?不幸的是,这种情况发生的原因有很多种:
* 许多编程语言运行时如Java虚拟机都有一个垃圾收集器GC偶尔需要停止所有正在运行的线程。这些“**停止世界stop-the-world**”GC暂停有时会持续几分钟【64】甚至像HotSpot JVM的CMS这样的所谓的“并行”垃圾收集器也不能完全与应用程序代码并行运行它需要不时地停止世界【65】。尽管通常可以通过改变分配模式或调整GC设置来减少暂停【66】但是如果我们想要提供健壮的保证就必须假设最坏的情况发生。
* 许多编程语言运行时如Java虚拟机都有一个垃圾收集器GC偶尔需要停止所有正在运行的线程。这些“**停止所有处理stop-the-world**”GC暂停有时会持续几分钟【64】甚至像HotSpot JVM的CMS这样的所谓的“并行”垃圾收集器也不能完全与应用程序代码并行运行它需要不时地停止所有处理【65】。尽管通常可以通过改变分配模式或调整GC设置来减少暂停【66】但是如果我们想要提供健壮的保证就必须假设最坏的情况发生。
* 在虚拟化环境中,可以**挂起suspend**虚拟机暂停执行所有进程并将内存内容保存到磁盘并恢复恢复内存内容并继续执行。这个暂停可以在进程执行的任何时候发生并且可以持续任意长的时间。这个功能有时用于虚拟机从一个主机到另一个主机的实时迁移而不需要重新启动在这种情况下暂停的长度取决于进程写入内存的速率【67】。
* 在最终用户的设备(如笔记本电脑)上,执行也可能被暂停并随意恢复,例如当用户关闭笔记本电脑的盖子时。
* 当操作系统上下文切换到另一个线程时或者当管理程序切换到另一个虚拟机时在虚拟机中运行时当前正在运行的线程可以在代码中的任意点处暂停。在虚拟机的情况下在其他虚拟机中花费的CPU时间被称为**窃取时间steal time**。如果机器处于沉重的负载下(即,如果等待运行的线程很长),暂停的线程再次运行可能需要一些时间。
@ -465,7 +465,7 @@ while(true){
在一个稍微不那么梦魇的场景中,半断开的节点可能会注意到它发送的消息没有被其他节点确认,因此意识到网络中必定存在故障。尽管如此,节点被其他节点错误地宣告为死亡,而半连接的节点对此无能为力。
第三种情况,想象一个经历了一个长时间**停止世界垃圾收集暂停stop-the-world GC Pause**的节点。节点的所有线程被GC抢占并暂停一分钟因此没有请求被处理也没有响应被发送。其他节点等待重试不耐烦并最终宣布节点死亡并将其丢到灵车上。最后GC完成节点的线程继续好像什么也没有发生。其他节点感到惊讶因为所谓的死亡节点突然从棺材中抬起头来身体健康开始和旁观者高兴地聊天。GC后的节点最初甚至没有意识到已经经过了整整一分钟而且自己已被宣告死亡。从它自己的角度来看从最后一次与其他节点交谈以来几乎没有经过任何时间。
第三种情况,想象一个经历了一个长时间**停止所有处理垃圾收集暂停stop-the-world GC Pause**的节点。节点的所有线程被GC抢占并暂停一分钟因此没有请求被处理也没有响应被发送。其他节点等待重试不耐烦并最终宣布节点死亡并将其丢到灵车上。最后GC完成节点的线程继续好像什么也没有发生。其他节点感到惊讶因为所谓的死亡节点突然从棺材中抬起头来身体健康开始和旁观者高兴地聊天。GC后的节点最初甚至没有意识到已经经过了整整一分钟而且自己已被宣告死亡。从它自己的角度来看从最后一次与其他节点交谈以来几乎没有经过任何时间。
这些故事的寓意是,节点不一定能相信自己对于情况的判断。分布式系统不能完全依赖单个节点,因为节点可能随时失效,可能会使系统卡死,无法恢复。相反,许多分布式算法都依赖于法定人数,即在节点之间进行投票(参阅“[读写的法定人数](ch5.md#读写的法定人数)“):决策需要来自多个节点的最小投票数,以减少对于某个特定节点的依赖。
@ -473,7 +473,7 @@ while(true){
最常见的法定人数是超过一半的绝对多数(尽管其他类型的法定人数也是可能的)。多数法定人数允许系统继续工作,如果单个节点发生故障(三个节点可以容忍单节点故障;五个节点可以容忍双节点故障)。系统仍然是安全的,因为在这个制度中只能有一个多数——不能同时存在两个相互冲突的多数决定。当我们在[第9章](ch9.md)中讨论**共识算法consensus algorithms**时,我们将更详细地讨论法定人数的应用。
#### 领导者与锁定
#### 领导者和锁
通常情况下,一些东西在一个系统中只能有一个。例如:
@ -495,25 +495,25 @@ while(true){
#### 防护令牌
当使用锁或租约来保护对某些资源(如[图8-4](img/fig8-4.png)中的文件存储)的访问时,需要确保一个被误认为自己是“天选者”的节点不能中断系统的其它部分。实现这一目标的一个相当简单的技术就是**防护fencing**,如[图8-5]()所示
当使用锁或租约来保护对某些资源(如[图8-4](img/fig8-4.png)中的文件存储)的访问时,需要确保一个被误认为自己是“天选者”的节点不能扰乱系统的其它部分。实现这一目标的一个相当简单的技术就是**防护fencing**,如[图8-5]()所示
![](img/fig8-5.png)
**图8-5 只允许以增加屏蔽令牌的顺序进行写操作,从而保证存储安全**
**图8-5 只允许以增加防护令牌的顺序进行写操作,从而保证存储安全**
我们假设每次锁定服务器授予锁或租约时,它还会返回一个**防护令牌fencing token**,这个数字在每次授予锁定时都会增加(例如,由锁定服务增加)。然后,我们可以要求客户端每次向存储服务发送写入请求时,都必须包含当前的屏蔽令牌。
我们假设每次锁定服务器授予锁或租约时,它还会返回一个**防护令牌fencing token**,这个数字在每次授予锁定时都会增加(例如,由锁定服务增加)。然后,我们可以要求客户端每次向存储服务发送写入请求时,都必须包含当前的防护令牌。
在[图8-5](img/fig8-5.png)中客户端1以33的令牌获得租约但随后进入一个长时间的停顿并且租约到期。客户端2以34的令牌该数字总是增加获取租约然后将其写入请求发送到存储服务包括34的令牌。稍后客户端1恢复生机并将其写入存储服务包括其令牌值33.但是存储服务器会记住它已经处理了一个具有更高令牌编号34的写入因此它会拒绝带有令牌33的请求。
如果将ZooKeeper用作锁定服务则可将事务标识`zxid`或节点版本`cversion`用作屏蔽令牌。由于它们保证单调递增因此它们具有所需的属性【74】。
如果将ZooKeeper用作锁定服务则可将事务标识`zxid`或节点版本`cversion`用作防护令牌。由于它们保证单调递增因此它们具有所需的属性【74】。
请注意,这种机制要求资源本身在检查令牌方面发挥积极作用,通过拒绝使用旧的令牌,而不是已经被处理的令牌来进行写操作——仅仅依靠客户端检查自己的锁状态是不够的。对于不明确支持屏蔽令牌的资源,可能仍然可以解决此限制(例如,在文件存储服务的情况下,可以将防护令牌包含在文件名中)。但是,为了避免在锁的保护之外处理请求,需要进行某种检查。
请注意,这种机制要求资源本身在检查令牌方面发挥积极作用,通过拒绝使用旧的令牌,而不是已经被处理的令牌来进行写操作——仅仅依靠客户端检查自己的锁状态是不够的。对于不明确支持防护令牌的资源,可能仍然可以解决此限制(例如,在文件存储服务的情况下,可以将防护令牌包含在文件名中)。但是,为了避免在锁的保护之外处理请求,需要进行某种检查。
在服务器端检查一个令牌可能看起来像是一个缺点但这可以说是一件好事一个服务假定它的客户总是守规矩并不明智因为使用客户端的人与运行服务的人优先级非常不一样【76】。因此任何服务保护自己免受意外客户的滥用是一个好主意。
### 拜占庭故障
屏蔽令牌可以检测和阻止无意中发生错误的节点(例如,因为它尚未发现其租约已过期)。但是,如果节点有意破坏系统的保证,则可以通过使用假屏蔽令牌发送消息来轻松完成此操作。
防护令牌可以检测和阻止无意中发生错误的节点(例如,因为它尚未发现其租约已过期)。但是,如果节点有意破坏系统的保证,则可以通过使用假防护令牌发送消息来轻松完成此操作。
在本书中我们假设节点是不可靠但诚实的它们可能很慢或者从不响应由于故障并且它们的状态可能已经过时由于GC暂停或网络延迟但是我们假设如果节点它做出了回应它正在说出“真相”尽其所知它正在按照协议的规则扮演其角色。
@ -529,16 +529,16 @@ while(true){
当一个系统在部分节点发生故障、不遵守协议、甚至恶意攻击、扰乱网络时仍然能继续正确工作,称之为**拜占庭容错Byzantine fault-tolerant**的,在特定场景下,这种担忧在是有意义的:
* 在航空航天环境中计算机内存或CPU寄存器中的数据可能被辐射破坏导致其以任意不可预知的方式响应其他节点。由于系统故障非常昂贵例如飞机撞毁和炸死船上所有人员或火箭与国际空间站相撞飞行控制系统必须容忍拜占庭故障【81,82】。
* 在航空航天环境中计算机内存或CPU寄存器中的数据可能被辐射破坏导致其以任意不可预知的方式响应其他节点。由于系统故障非常昂贵例如飞机撞毁和炸死船上所有人员或火箭与国际空间站相撞飞行控制系统必须容忍拜占庭故障【81,82】。
* 在多个参与组织的系统中一些参与者可能会试图欺骗或欺骗他人。在这种情况下节点仅仅信任另一个节点的消息是不安全的因为它们可能是出于恶意的目的而被发送的。例如像比特币和其他区块链一样的对等网络可以被认为是让互不信任的各方同意交易是否发生的一种方式而不依赖于中央当局【83】。
然而在本书讨论的那些系统中我们通常可以安全地假设没有拜占庭式的错误。在你的数据中心里所有的节点都是由你的组织控制的所以他们可以信任辐射水平足够低内存损坏不是一个大问题。制作拜占庭容错系统的协议相当复杂【84】而容错嵌入式系统依赖于硬件层面的支持【81】。在大多数服务器端数据系统中部署拜占庭容错解决方案的成本使其变得不切实际。
Web应用程序确实需要预期受终端用户控制的客户端如Web浏览器的任意和恶意行为。这就是为什么输入验证清理和输出转义如此重要例如防止SQL注入和跨站点脚本。但是我们通常不使用拜占庭容错协议而只是让服务器决定什么是客户端行为而不是允许的。在没有这种中心授权的对等网络中拜占庭容错更为重要。
Web应用程序确实需要预期受终端用户控制的客户端如Web浏览器的任意和恶意行为。这就是为什么输入验证数据清洗和输出转义如此重要例如防止SQL注入和跨站点脚本。但是我们通常不使用拜占庭容错协议而只是让服务器决定什么是客户端行为而不是允许的。在没有这种中心授权的对等网络中拜占庭容错更为重要。
软件中的一个错误可能被认为是拜占庭式的错误但是如果您将相同的软件部署到所有节点上那么拜占庭式的容错算法不能为您节省。大多数拜占庭式容错算法要求超过三分之二的节点能够正常工作如果有四个节点最多只能有一个故障。要使用这种方法对付bug你必须有四个独立的相同软件的实现并希望一个bug只出现在四个实现之一中。
同样,如果一个协议可以保护我们免受漏洞,安全妥协和恶意攻击,那么这将是有吸引力的。不幸的是,这也是不现实的:在大多数系统中,如果攻击者可以渗透一个节点,那他们可能会渗透所有这些节点,因为它们可能运行相同的软件。因此传统机制(认证,访问控制,加密,防火墙等)仍然是攻击者的主要保护措施。
同样,如果一个协议可以保护我们免受漏洞,安全妥协和恶意攻击,那么这将是有吸引力的。不幸的是,这也是不现实的:在大多数系统中,如果攻击者可以渗透一个节点,那他们可能会渗透所有这些节点,因为它们可能运行相同的软件。因此传统机制(认证,访问控制,加密,防火墙等)仍然是抵御攻击者的主要保护措施。
#### 弱谎言形式
@ -589,11 +589,11 @@ while(true){
为了定义算法是正确的,我们可以描述它的属性。例如,排序算法的输出具有如下特性:对于输出列表中的任何两个不同的元素,左边的元素比右边的元素小。这只是定义对列表进行排序含义的一种形式方式。
同样,我们可以写下我们想要的分布式算法的属性来定义它的正确含义。例如,如果我们正在为一个锁生成屏蔽令牌(参阅“[屏蔽令牌](屏蔽令牌)”),我们可能要求算法具有以下属性:
同样,我们可以写下我们想要的分布式算法的属性来定义它的正确含义。例如,如果我们正在为一个锁生成防护令牌(参阅“[防护令牌](防护令牌)”),我们可能要求算法具有以下属性:
***唯一性***
没有两个屏蔽令牌请求返回相同的值。
没有两个防护令牌请求返回相同的值。
***单调序列***
@ -616,7 +616,7 @@ while(true){
* 如果安全属性被违反,我们可以指向一个特定的时间点(例如,如果违反了唯一性属性,我们可以确定重复的防护令牌返回的特定操作) 。违反安全属性后,违规行为不能撤销——损失已经发生。
* 活性属性反过来:在某个时间点(例如,一个节点可能发送了一个请求,但还没有收到响应),它可能不成立,但总是希望在未来(即通过接受答复)。
区分安全性和活性属性的一个优点是可以帮助我们处理困难的系统模型。对于分布式算法在系统模型的所有可能情况下要求始终保持安全属性是常见的【88】。也就是说即使所有节点崩溃或者整个网络出现故障算法仍然必须确保它不会返回错误的结果即保证安全性得到满足
区分安全性和活性属性的一个优点是可以帮助我们处理困难的系统模型。对于分布式算法,在系统模型的所有可能情况下,要求**始终**保持安全属性是常见的【88】。也就是说即使所有节点崩溃或者整个网络出现故障算法仍然必须确保它不会返回错误的结果即保证安全性得到满足
但是,对于活性属性,我们可以提出一些注意事项:例如,只有在大多数节点没有崩溃的情况下,只有当网络最终从中断中恢复时,我们才可以说请求需要接收响应。部分同步模型的定义要求系统最终返回到同步状态——即任何网络中断的时间段只会持续一段有限的时间,然后进行修复。
@ -624,13 +624,13 @@ while(true){
安全性和活性属性以及系统模型对于推理分布式算法的正确性非常有用。然而,在实践中实施算法时,现实的混乱事实再一次地让你咬牙切齿,很明显系统模型是对现实的简化抽象。
例如,在故障恢复模型中的算法通常假设稳定存储器中的数据经历了崩溃。但是,如果磁盘上的数据被破坏,或者由于硬件错误或错误配置导致数据被清除,会发生什么情况?如果服务器存在固件错误并且在重新启动时无法识别其硬盘驱动器,即使驱动器已正确连接到服务器,会发生什么情况?
例如,在故障恢复模型中的算法通常假设稳定存储器中的数据经历了崩溃。但是,如果磁盘上的数据被破坏,或者由于硬件错误或错误配置导致数据被清除,会发生什么情况?如果服务器存在固件错误并且在重新启动时无法识别其硬盘驱动器,即使驱动器已正确连接到服务器,那又会发生什么情况?
法定人数算法(参见“[读写法定人数](ch5.md#读写法定人数)”)依赖节点来记住它声称存储的数据。如果一个节点可能患有健忘症,忘记了以前存储的数据,这会打破法定条件,从而破坏算法的正确性。也许需要一个新的系统模型,在这个模型中,我们假设稳定的存储大多存在崩溃,但有时可能会丢失。但是那个模型就变得更难以推理了。
算法的理论描述可以简单宣称一些事在假设上是不会发生的——在非拜占庭式系统中。但实际上我们还是需要对可能发生和不可能发生的故障做出假设,真实世界的实现,仍然会包括处理“假设上不可能”情况的代码,即使代码可能就是`printf("you sucks")`和`exit(666)`,实际上也就是留给运维来擦屁股。(这可以说是计算机科学和软件工程间的一个差异)。
这并不是说理论上抽象的系统模型是毫无价值的,恰恰相反。它们对于将实际系统的复杂性降低到一个我们可以推理的可处理的错误是非常有帮助的,以便我们能够理解这个问题,并试图系统地解决这个问题。我们可以证明算法是正确的,通过显示它们的属性总是保持在某个系统模型中
这并不是说理论上抽象的系统模型是毫无价值的,恰恰相反。它们对于将实际系统的复杂性降低到一个我们可以推理的可处理的错误是非常有帮助的,以便我们能够理解这个问题,并试图系统地解决这个问题。我们可以证明算法是正确的,通过表明它们的属性总是保持在某个系统模型中
证明算法正确并不意味着它在真实系统上的实现必然总是正确的。但这迈出了很好的第一步,因为理论分析可以发现算法中的问题,这种问题可能会在现实系统中长期潜伏,直到你的假设(例如,时间)因为不寻常的情况被打破。理论分析与经验测试同样重要。
@ -642,7 +642,7 @@ while(true){
* 当您尝试通过网络发送数据包时,数据包可能会丢失或任意延迟。同样,答复可能会丢失或延迟,所以如果你没有得到答复,你不知道消息是否通过。
* 节点的时钟可能会与其他节点显著不同步尽管您尽最大努力设置NTP它可能会突然跳转或跳回依靠它是很危险的因为您很可能没有好的测量你的时钟的错误间隔。
* 一个进程可能会在其执行的任何时候暂停一段相当长的时间(可能是因为世界上的垃圾收集器),被其他节点宣告死亡,然后再次复活,却没有意识到它被暂停了。
* 一个进程可能会在其执行的任何时候暂停一段相当长的时间(可能是因为停止所有处理的垃圾收集器),被其他节点宣告死亡,然后再次复活,却没有意识到它被暂停了。
这类**部分失效**可能发生的事实是分布式系统的决定性特征。每当软件试图做任何涉及其他节点的事情时,偶尔就有可能会失败,或者随机变慢,或者根本没有响应(最终超时)。在分布式系统中,我们试图在软件中建立**部分失效**的容错机制,这样整个系统即使在某些组成部分被破坏的情况下,也可以继续运行。

42
ch9.md
View File

@ -31,11 +31,11 @@
在“[复制延迟问题](ch5.md#复制延迟问题)”中,我们看到了数据库复制中发生的一些时序问题。如果你在同一时刻查看两个数据库节点,则可能在两个节点上看到不同的数据,因为写请求在不同的时间到达不同的节点。无论数据库使用何种复制方法(单主复制,多主复制或无主复制),都会出现这些不一致情况。
大多数复制的数据库至少提供了**最终一致性**这意味着如果你停止向数据库写入数据并等待一段不确定的时间那么最终所有的读取请求都会返回相同的值【1】。换句话说不一致性是暂时的最终会自行解决假设网络中的任何故障最终都会被修复。最终一致性的一个更好的名字可能是**收敛convergence**,因为我们预计所有的本最终会收敛到相同的值【2】。
大多数复制的数据库至少提供了**最终一致性**这意味着如果你停止向数据库写入数据并等待一段不确定的时间那么最终所有的读取请求都会返回相同的值【1】。换句话说不一致性是暂时的最终会自行解决假设网络中的任何故障最终都会被修复。最终一致性的一个更好的名字可能是**收敛convergence**,因为我们预计所有的本最终会收敛到相同的值【2】。
然而,这是一个非常弱的保证 —— 它并没有说什么什么时候副本会收敛。在收敛之前读操作可能会返回任何东西或什么都没有【1】。例如如果你写入了一个值然后立即再次读取这并不能保证你能看到刚跟写入的值因为读请求可能会被路由到另外的副本上。参阅“[读己之写](ch5.md#读己之写)” )。
然而,这是一个非常弱的保证 —— 它并没有说什么时候副本会收敛。在收敛之前读操作可能会返回任何东西或什么都没有【1】。例如如果你写入了一个值然后立即再次读取这并不能保证你能看到刚跟写入的值因为读请求可能会被路由到另外的副本上。参阅“[读己之写](ch5.md#读己之写)” )。
对于应用开发人员而言,最终一致性是很困难的,因为它与普通单线程程序中变量的行为有很大区别。如果将一个值赋给一个变量,然后很快地再次读取,会认为可能读到旧的值或者读取失败。数据库表面上看起来像一个你可以读写的变量但实际上它有更复杂的语义【3】。
对于应用开发人员而言,最终一致性是很困难的,因为它与普通单线程程序中变量的行为有很大区别。对于后者,如果将一个值赋给一个变量然后很快地再次读取不可能读到旧的值或者读取失败。数据库表面上看起来像一个你可以读写的变量但实际上它有更复杂的语义【3】。
在与只提供弱保证的数据库打交道时,你需要始终意识到它的局限性,而不是意外地作出太多假设。错误往往是微妙的,很难找到,也很难测试,因为应用可能在大多数情况下运行良好。当系统出现故障(例如网络中断)或高并发时,最终一致性的边缘情况才会显现出来。
@ -73,7 +73,7 @@
线性一致性背后的基本思想很简单:使系统看起来好像只有一个数据副本。然而确切来讲,实际上有更多要操心的地方。为了更好地理解线性一致性,让我们再看几个例子。
[图9-2](img/fig9-2.png) 显示了三个客户端在线性一致数据库中同时读写相同的键`x`。在分布式系统文献中,`x`被称为**寄存器register**,例如,它可以是键值存储中的一个**键**,关系数据库中的一**行**,或文档数据库中的一个**文档**。
![](img/fig9-2.png)
**图9-2 如果读取请求与写入请求并发,则可能会返回旧值或新值**
@ -148,9 +148,9 @@
>
> **线性一致性Linearizability**是读取和写入寄存器(单个对象)的**新鲜度保证**。它不会将操作组合为事务,因此它也不会阻止写偏差等问题(参阅“[写偏差和幻读](ch7.md#写偏差和幻读)”),除非采取其他措施(例如[物化冲突](ch7.md#物化冲突))。
>
> 一个数据库可以提供可串行性和线性一致性,这种组合被称为严格的可串行性或强的**单副本强可串行性strong-1SR**【4,13】。基于两阶段锁定的可串行化实现(参见“[两阶段锁定2PL](#两阶段锁定2PL)”一节)或**实际串行执行**(参见第“[实际串行执行](ch7.md#实际串行执行)”)通常是线性一致性的。
> 一个数据库可以提供可序列化和线性一致性,这种组合被称为严格的可序列化或强的**强单副本可序列化strong-1SR**【4,13】。基于两阶段锁定的可序列化实现(参见“[两阶段锁定2PL](#两阶段锁定2PL)”一节)或**实际串行执行**(参见第“[实际串行执行](ch7.md#实际串行执行)”)通常是线性一致性的。
>
> 但是,可序列化的快照隔离(参见“[可序列化的快照隔离SSI](ch7.md#可序列化的快照隔离SSI)”)不是线性一致性的:按照设计,它可以从一致的快照中进行读取,以避免锁定读者和写者之间的争。一致性快照的要点就在于**它不会包括比快照更新的写入**,因此从快照读取不是线性一致性的。
> 但是,可序列化的快照隔离(参见“[可序列化的快照隔离SSI](ch7.md#可序列化的快照隔离SSI)”)不是线性一致性的:按照设计,它从一致的快照中进行读取,以避免读者和写者之间的锁竞争。一致性快照的要点就在于**它不会包括该快照之后的写入**,因此从快照读取不是线性一致性的。
@ -162,11 +162,11 @@
一个使用单主复制的系统需要确保领导真的只有一个而不是几个脑裂。一种选择领导者的方法是使用锁每个节点在启动时尝试获取锁成功者成为领导者【14】。不管这个锁是如何实现的它必须是线性一致的所有节点必须就哪个节点拥有锁达成一致否则就没用了。
诸如Apache ZooKeeper 【15】和etcd 【16】之类的协调服务通常用于实现分布式锁和领导者选举。它们使用一致性算法以容错的方式实现线性一致的操作在本章后面的“[容错共识](#容错共识)”中讨论此类算法)[^iii]。还有许多微妙的细节来正确地实现锁和领导者选择(例如,参阅“[领导者和锁](#领导者和锁)”中的屏蔽问题而像Apache Curator 【17】这样的库则通过在ZooKeeper之上提供更高级别的配方来提供帮助。但是线性一致性存储服务是这些协调任务的基础。
诸如Apache ZooKeeper 【15】和etcd 【16】之类的协调服务通常用于实现分布式锁和领导者选举。它们使用一致性算法以容错的方式实现线性一致的操作在本章后面的“[容错共识](#容错共识)”中讨论此类算法)[^iii]。还有许多微妙的细节来正确地实现锁和领导者选举(例如,参阅“[领导者和锁](#领导者和锁)”中的防护问题而像Apache Curator 【17】这样的库则通过在ZooKeeper之上提供更高级别的配方来提供帮助。但是线性一致性存储服务是这些协调任务的基础。
[^iii]: 严格地说ZooKeeper和etcd提供线性一致性的写操作但读取可能是陈旧的因为默认情况下它们可以由任何一个副本服务。你可以选择请求线性一致性读取etcd调用这个法定读取【16】而在ZooKeeper中你需要在读取【15】之前调用`sync()`。参阅“[使用全局顺序广播实现线性存储](#使用全局顺序广播实现线性存储)”。
分布式锁也在一些分布式数据库如Oracle Real Application ClustersRAC【18】以更细的粒度使用。 RAC对每个磁盘页面使用一个锁多个节点共享对同一个磁盘存储系统的访问权限。由于这些线性一致的锁处于事务执行的关键路径上RAC部署通常具有用于数据库节点之间通信的专用集群互连网络。
分布式锁也在一些分布式数据库如Oracle Real Application ClustersRAC【18】更多的粒度级别上使用。RAC对每个磁盘页面使用一个锁多个节点共享对同一个磁盘存储系统的访问权限。由于这些线性一致的锁处于事务执行的关键路径上RAC部署通常具有用于数据库节点之间通信的专用集群互连网络。
#### 约束和唯一性保证
@ -176,9 +176,9 @@
如果想要确保银行账户余额永远不会为负数,或者不会出售比仓库里的库存更多的物品,或者两个人不会都预定了航班或剧院里同一时间的同一个位置。这些约束条件都要求所有节点都同意一个最新的值(账户余额,库存水平,座位占用率)。
在实际应用中,处理这些限制有时是可以接受的(例如,如果航班超额预订,你可以将客户转移到不同的航班并为其提供补偿)。在这种情况下,可能不需要线性一致性,我们将在“[及时性与完整性](ch12.md#及时性与完整性)”中讨论这种松散解释的约束。
在实际应用中,宽松地处理这些限制有时是可以接受的(例如,如果航班超额预订,你可以将客户转移到不同的航班并为其提供补偿)。在这种情况下,可能不需要线性一致性,我们将在“[及时性与完整性](ch12.md#及时性与完整性)”中讨论这种松的约束。
然而,一个硬性的唯一性约束(关系型数据库中常见的那种)需要线性一致性。其他类型的约束,如外键或属性约束,可以不需要线性一致性的情况下实现【19】。
然而一个硬性的唯一性约束关系型数据库中常见的那种需要线性一致性。其他类型的约束如外键或属性约束可以不需要线性一致性【19】。
#### 跨信道的时序依赖
@ -214,7 +214,7 @@
***共识算法(线性一致)***
一些在本章后面讨论的共识算法与单领导者复制类似。然而共识协议包含防止脑裂和陈旧副本的措施。由于这些细节共识算法可以安全地实现线性一致性存储。例如Zookeeper 【21】和etcd 【22】就是这样工作的。
一些在本章后面讨论的共识算法,与单领导者复制类似。然而,共识协议包含防止脑裂和陈旧副本的措施。正是由于这些细节共识算法可以安全地实现线性一致性存储。例如Zookeeper 【21】和etcd 【22】就是这样工作的。
***多主复制(非线性一致)***
@ -226,7 +226,7 @@
基于时钟例如在Cassandra中参见“[依赖同步时钟](ch8.md#依赖同步时钟)”)的“最后写入胜利”冲突解决方法几乎可以确定是非线性的,由于时钟偏差,不能保证时钟的时间戳与实际事件顺序一致。[松散的法定人数](ch5.md#马虎法定人数和暗示交接)也破坏了线性一致的可能性。即使使用严格的法定人数,非线性一致的行为也是可能的,如下节所示。
基于时钟例如在Cassandra中参见“[依赖同步时钟](ch8.md#依赖同步时钟)”)的“最后写入胜利”冲突解决方法几乎可以确定是非线性的,由于时钟偏差,不能保证时钟的时间戳与实际事件顺序一致。[宽松的法定人数](ch5.md#宽松的法定人数与提示移交)也破坏了线性一致的可能性。即使使用严格的法定人数,非线性一致的行为也是可能的,如下节所示。
#### 线性一致性和法定人数
@ -238,9 +238,9 @@
在[图9-6](img/fig9-6.png)中,$x$ 的初始值为0写入客户端通过向所有三个副本 $n = 3, w = 3$ )发送写入将 $x$ 更新为 `1`。客户端A并发地从两个节点组成的法定人群 $r = 2$ )中读取数据,并在其中一个节点上看到新值 `1` 。客户端B也并发地从两个不同的节点组成的法定人数中读取并从两个节点中取回了旧值 `0`
仲裁条件满足( $w + r> n$ 但是这个执行是非线性一致的B的请求在A的请求完成后开始但是B返回旧值而A返回新值。 又一次如同Alice和Bob的例子 [图9-1]()
法定人数条件满足( $w + r> n$ 但是这个执行是非线性一致的B的请求在A的请求完成后开始但是B返回旧值而A返回新值。 又一次如同Alice和Bob的例子 [图9-1]()
有趣的是通过牺牲性能可以使Dynamo风格的法定人数线性化读取者必须在将结果返回给应用之前同步执行读修复参阅“[读时修复与反熵过程](ch5.md#读时修复与反熵过程)”) 并且写入者必须在发送写入之前读取法定数量节点的最新状态【24,25】。然而由于性能损失Riak不执行同步读修复【26】。 Cassandra在进行法定人数读取时**确实**在等待读修复完成【27】但是由于使用了最后写入为准的冲突解决方案,当同一个键有多个并发写入时,将不能保证线性一致性。
有趣的是通过牺牲性能可以使Dynamo风格的法定人数线性化读取者必须在将结果返回给应用之前同步执行读修复参阅“[读时修复与反熵过程](ch5.md#读时修复与反熵过程)”) 并且写入者必须在发送写入之前读取法定数量节点的最新状态【24,25】。然而由于性能损失Riak不执行同步读修复【26】。 Cassandra在进行法定人数读取时**确实**在等待读修复完成【27】但是由于使用了最后写入胜利的冲突解决方案,当同一个键有多个并发写入时,将不能保证线性一致性。
而且这种方式只能实现线性一致的读写不能实现线性一致的比较和设置操作因为它需要一个共识算法【28】。
@ -266,7 +266,7 @@
在单主配置的条件下,如果数据中心之间的网络被中断,则连接到从库数据中心的客户端无法联系到主库,因此它们无法对数据库执行任何写入,也不能执行任何线性一致的读取。它们仍能从从库读取,但结果可能是陈旧的(非线性一致)。如果应用需要线性一致的读写,却又位于与主库网络中断的数据中心,则网络中断将导致这些应用不可用。
如果客户端可以直接连接到主库所在的数据中心,这就不是问题了,哪些应用可以继续正常工作。但直到网络链接修复之前,只能访问从库数据中心的客户端会中断运行。
如果客户端可以直接连接到主库所在的数据中心,这就不是问题了,那些应用可以继续正常工作。但只能访问从库数据中心的客户端会中断运行,直到网络链接得到修复
#### CAP定理
@ -285,7 +285,7 @@
>
> CAP有时以这种面目出现一致性可用性和分区容错性三者只能择其二。不幸的是这种说法很有误导性【32】因为网络分区是一种错误所以它并不是一个选项不管你喜不喜欢它都会发生【38】。
>
> 在网络正常工作的时候,系统可以提供一致性(线性一致性)和整体可用性。发生网络故障时,你必须在线性一致性和整体可用性之间做出选择。因此,一个更好的表达CAP的方法可以是一致的或者在分区时可用【39】。一个更可靠的网络需要减少这个选择但是在某些时候选择是不可避免的。
> 在网络正常工作的时候,系统可以提供一致性(线性一致性)和整体可用性。发生网络故障时,你必须在线性一致性和整体可用性之间做出选择。因此,CAP更好的表述成在分区时要么选择一致要么选择可用【39】。一个更可靠的网络需要减少这个选择但是在某些时候选择是不可避免的。
>
> 在CAP的讨论中术语可用性有几个相互矛盾的定义形式化作为一个定理【30】并不符合其通常的含义【40】。许多所谓的“高可用”容错系统实际上不符合CAP对可用性的特殊定义。总而言之围绕着CAP有很多误解和困惑并不能帮助我们更好地理解系统所以最好避免使用CAP。
@ -334,7 +334,7 @@
因果关系对事件施加了一种**顺序**:因在果之前;消息发送在消息收取之前。而且就像现实生活中一样,一件事会导致另一件事:某个节点读取了一些数据然后写入一些结果,另一个节点读取其写入的内容,并依次写入一些其他内容,等等。这些因果依赖的操作链定义了系统中的因果顺序,即,什么在什么之前发生。
如果一个系统服从因果关系所规定的顺序,我们说它是**因果一致causally**的。例如,快照隔离提供了因果一致性:当你从数据库中读取到一些数据时,你一定还能够看到其因果前驱(假设在此期间这些数据还没有被删除)。
如果一个系统服从因果关系所规定的顺序,我们说它是**因果一致causally consistent**的。例如,快照隔离提供了因果一致性:当你从数据库中读取到一些数据时,你一定还能够看到其因果前驱(假设在此期间这些数据还没有被删除)。
@ -408,7 +408,7 @@
如果主库不存在(可能因为使用了多主数据库或无主数据库,或者因为使用了分区的数据库),如何为操作生成序列号就没有那么明显了。在实践中有各种各样的方法:
* 每个节点都可以生成自己独立的一组序列号。例如有两个节点,一个节点只能生成奇数,而另一个节点只能生成偶数。通常,可以在序列号的二进制表示中预留一些位,用于唯一的节点标识符,这样可以确保两个不同的节点永远不会生成相同的序列号。
* 可以将时钟物理时钟时间戳附加到每个操作上【55】。这种时间戳并不连续但是如果它具有足够高的分辨率那也许足以提供一个操作的全序关系。这一事实应用于 *最后写入为准* 的冲突解决方法中(参阅“[有序事件的时间戳](ch8.md#有序事件的时间戳)”)。
* 可以将时钟物理时钟时间戳附加到每个操作上【55】。这种时间戳并不连续但是如果它具有足够高的分辨率那也许足以提供一个操作的全序关系。这一事实应用于 *最后写入胜利* 的冲突解决方法中(参阅“[有序事件的时间戳](ch8.md#有序事件的时间戳)”)。
* 可以预先分配序列号区块。例如,节点 A 可能要求从序列号1到1,000区块的所有权而节点 B 可能要求序列号1,001到2,000区块的所有权。然后每个节点可以独立分配所属区块中的序列号并在序列号告急时请求分配一个新的区块。
这三个选项都比单一主库的自增计数器表现要好,并且更具可扩展性。它们为每个操作生成一个唯一的,近似自增的序列号。然而它们都有同一个问题:生成的序列号与因果不一致。
@ -462,7 +462,7 @@
总之:为了实诸如如用户名上的唯一约束这种东西,仅有操作的全序是不够的,你还需要知道这个全序何时会尘埃落定。如果你有一个创建用户名的操作,并且确定在全序中,没有任何其他节点可以在你的操作之前插入对同一用户名的声称,那么你就可以安全地宣告操作执行成功。
如何知道你的全序关系已经尘埃落定,这个想法将在[全序广播](#全序广播)一节中详细说明。
如何确定全序关系已经尘埃落定,这将在[全序广播](#全序广播)一节中详细说明。
### 全序广播
@ -482,7 +482,7 @@
没有消息丢失:如果消息被传递到一个节点,它将被传递到所有节点。
**全序交付totally ordered delivery***
***全序交付totally ordered delivery***
消息以相同的顺序传递给每个节点。
@ -674,7 +674,7 @@
### 实践中的分布式事务
布式事务的名声毁誉参半尤其是那些通过两阶段提交实现的。一方面它被视作提供了一个难以实现的重要的安全性保证另一方面它们因为导致运维问题造成性能下降做出超过能力范围的承诺而饱受批评【81,82,83,84】。许多云服务由于其导致的运维问题而选择不实现分布式事务【85,86】。
分布式事务的名声毁誉参半尤其是那些通过两阶段提交实现的。一方面它被视作提供了一个难以实现的重要的安全性保证另一方面它们因为导致运维问题造成性能下降做出超过能力范围的承诺而饱受批评【81,82,83,84】。许多云服务由于其导致的运维问题而选择不实现分布式事务【85,86】。
分布式事务的某些实现会带来严重的性能损失 —— 例如据报告称MySQL中的分布式事务比单节点事务慢10倍以上【87】所以当人们建议不要使用它们时就不足为奇了。两阶段提交所固有的性能成本大部分是由于崩溃恢复所需的额外强制刷盘`fsync`【88】以及额外的网络往返。

View File

@ -264,7 +264,7 @@
### 法定人数quorum
在操作完成之前,需要对操作进行投票的最少节点数量。 请参阅第179页上的“读写的法定人数”。
在操作完成之前,需要对操作进行投票的最少节点数量。 请参阅第179页上的“读写的法定人数”。