Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

区块链核心算法之——Paxos算法

救世主在哪儿
95 0 0
比特币、以太坊、区块链基础知识、应用场景及其数学原理基本上让币爷撸了个遍。但是你币爷不是一个容易满足的人,在了解了区块链、数字货币的基础知识上,我们能不. ?1 A4 l( p+ P# z1 f9 M9 N

/ }9 w, |8 D  C0 F& D    能进一步摸索区块链的底层算法原理?币爷从今天开始,打算花几期时间来和大家一起研究一下区块链的核心算法,死磕到底!
1 G. h* D% f  b$ `: ]5 Q  S( O# _+ i* q$ Q( y7 R! r; f
    今天我们的计算机和信息系统本质上都是分布式的。越来越多的公司进入全球化时代,它们拥有部署在不同大陆上的成千上万的计算机。数据存储在不同的数据中心,而计算机任务则运行在多台计算机上。
. r' `" r8 U, @% M2 {9 ~. M+ D2 O8 f: N" L( w. N
    虽然分布式系统带来了很多好处,比如扩大存储容量和计算能力,甚至有可能连接地理空间上分离的区域,然而它也带来了一个很麻烦的协调问题(CoordinationProblems)。在分布式系统中,协调问题是很常见的。即便是一个分布式系统中的每个节点(如计算机、核、网络交换机等)几年才发生一次故障,但如果系统包含数百万个节点,那么平均每分钟都将发生一次故障。从好的方面讲,人们期待一个多节点的分布式系统可以容忍一些错误并且持续正常工作。! z: {: K8 ?* C. a( R! J; ?* d$ R
' }) L" {$ `* G$ T
    我们应该如何创建一个容错的分布式系统呢?本期将从一些简单的问题开始,一步步改进我们的方案,最终将得到Paxos,一个甚至可以在逆境下工作的协议。4 ~+ F* W$ d9 k9 [! ~
- d' g# S' E  o& x
    客户端/服务器
$ T. ]3 `2 {' x! g/ Q
9 ^* C, O- @6 h1 r    定义1.1(节点(Node)).系统中一个工作单元被称为节点(Node)。在一个计算机网络中,所有的计算机都是节点。在经典的客户端/服务器模式下,服务器和客户端都是节点。这里,如不做另外说明,我们假设系统中节点的总数为n.5 h9 f+ u6 ]9 j. y& `
+ F+ P) B8 d5 R$ ?2 ]
    模型1.2(消息传递(MessagePassing)).我们在消息传递模式(MessagePassingModel)下研究由一组节点构成的分布式系统。每个节点都能进行本地运算,并可以向所有其他节点发送消息。
( |9 @' T) o6 Y
  }" \- |/ o  ^$ B: t0 {    补充评论与注解:
7 T6 M3 P5 W$ i+ r( n# z* k8 h* S' A" Z7 T1 V
    我们从最小的分布式系统(仅包含两个节点)开始。该系统中有一个客户端节点,它希望操作(比如存储或更新)在远程服务器节点上的数据。
) O7 f7 J0 C! [" ^4 w, r1 h. q
+ U* A  v$ b& F$ Y. o" h% y# b    算法1.3朴素的客户端/服务器算法- t: H7 m7 T$ ]0 E0 I" n

$ l& y4 z9 ]4 s9 t    1:客户端每次向服务器发送一条命令
9 F8 [' u$ b- T6 }0 b, s! n& _8 _* z7 @) U  L
    模型1.4(消息丢失(MessageLoss)).
0 A6 D  d3 K( _  S' K' W) D  d; Z) m+ r- ?
    在存在消息丢失(MessageLoss)的消息传递模式下,任何一条消息都不能保证可以安全地到达消息的接受者。
% P( R% a8 F3 x; J( S, W' e6 w) B9 z8 r5 S+ S; m
    补充评论与注解:
/ ]* u' S) y/ U: O2 g. [+ W% Z( y& i# ^2 T' @, B/ S
    一个相关的问题是消息损坏,即收到了一条消息,但是其内容已经损坏了。实际上,与消息丢失相比,我们可以更好地处理消息损坏,比如在消息中增加校验码。2 P: Y" X1 S3 g7 w9 I& y; O

% W6 Y9 |# W+ G# w: X" m9 Z2 q    如果消息丢失,则算法1.3不能正常工作。因此我们需要一点小改进。; A. {. S9 e7 i8 f  N" n

6 Q" i' o) f$ P& b2 I    算法1.5带确认(Acknowledgements)的客户端/服务器算法
) T) R& [( |2 f- n: O% X& \) M3 y, {1 D  R, \0 j, p0 J3 P5 S, d/ e! o
    1:客户端每次向服务器发送一条命令1 |  m8 p! a$ b# R

( o* ^+ H8 O; A0 K- Q    2:服务器每收到一条命令,都会发送一条确认信息
! }, N) I( t! R6 @8 o, ?" R  b7 u( q+ t  q! i
    3:如果客户端没有在一个合理的时间内收到确认信息,它将重新发送命令。% J0 S% F) m5 z2 P1 {- L2 e

; R9 N8 J# F  b$ u- @    补充评论与注解:9 R' e9 ?; ~, L+ E0 g9 J
0 ]6 M3 _' ?2 Q+ k  A4 F( v% T7 c
    “每次发送一条命令”意味着如果一个客户端发送了一条命令c,那么在它收到服务器对c的确认信息之前,它将不会发送任何新的命令c'。3 E) f2 W) x3 F7 Y7 d# V

  `1 w! x4 G# j& Y/ z    不但客户端发送的信息可能丢失,服务器发送的确认消息也可能丢失。如果一条确认信息丢失,那么客户端可能重新发送一条消息,即使该消息已经被服务器接受且执行。为了避免重复执行相同的信息,我们可以给每条消息加上序列号,这样接收者可以辨识出重复的消息。" I1 \- Q+ K% y- {3 n8 S: c) L6 f
3 G2 c5 Y5 v8 ]8 c! Q3 |1 n
    这个看似简单的算法是很多可靠协议的基础,比如TCP。
, s" [5 r0 Q; T# O/ @9 q7 N) |! _8 {. d0 j! |) {( j, [
    算法可以很容易地拓展到多个服务器的场景:客户端发送一条命令给每个服务器,一旦客户端收到所有服务器的确认消息,就可以认为该命令已被成功执行。但是如何处理多个客户端的情况呢?
3 I0 q2 O3 E$ V8 @& b% t2 J( B" P
    模型1.6(可变消息延迟(VariableMessageDelay)).在实际应用中,消息传输花费的时间是不同的。即使是在相同的一对节点间传输信息,所耗费的时间也可能不同。这里我们假定都是可变消息延迟模式。
& w4 q7 h' K6 U  x4 x' a5 G, ]
( t' O8 `* s$ M# h    定理1.7.如果算法1.5在多个服务器和多个客户端间运行,服务器接收到的命令顺序可能是不同的,这将导致不一致的状态。
" s% J" W, S, q2 `/ ?, e/ D# t8 O
    证明.假定我们有两个客户端u1和u2,以及两个服务器s1和s2。两个服务器上都在维护同一个变量x的值,起始状态,x=0。两个客户端都在向服务器发送命令去更新x的值。u1的命令是x=x+1,而u2的命令是x=2*x。假设两个客户端同时发送它们的命令。因为有消息延迟,有可能s1先接到u1的命令,而s2先收到u2的命令。于是,在s1上执行两个命令的结果是x=(0+1)*2=2,而在s2上计算的结果则是x=(0*2)+1=1。
0 D/ P/ v: C1 J7 f( o/ i- n. {# l9 @, E7 O5 `
    定义1.8(状态复制(StateReplication)).对于一组节点,如果所有节点均以相同的顺序执行一个(可能是无限的)命令序列c1,c2,c3,…,则这组节点实现了状态复制(StateReplication)。
' U3 ]  E# n( ^) P: E: ^
* S& x, e8 ]1 [    补充评论与注解:9 M& C+ U8 X. ~6 q3 Y
* R8 B$ s* o: @3 _* U) D
    状态复制是分布式系统的基本性质:
+ r7 d4 |6 W& o/ L* H/ ]
2 u+ X& R" M+ z    对于金融科技业的从业人员来说,状态复制经常等同于区块链。6 n) }+ S" x% T) s- x. k+ G
6 \+ Y7 U0 B8 M
    因为单个服务器可以天然实现状态复制,我们可以将单个服务器视为一个串行化器(Serializer)。通过让串行化器来分发命令,自动对请求进行排序并获得状态复制。
9 Z+ x4 L$ D) X* P3 a
/ y( a; V* u' ?: N; C; z8 T+ P    算法1.9借助单一串行化器实现状态复制4 G* v7 _; I8 v, K. t
, {/ `- X( v) x2 |0 F6 e
    1:所有的客户端都向串行化器发送命令,每次发送一条
. e0 D7 i' Z; T. @/ ~6 r' ]* s* s' _: }" A7 Y& d1 u
    2:串行化器将命令逐条转发给所有的服务器/ o$ O1 H" G. L7 q
: m/ U$ H6 c* O; `- P2 Y
    3:(针对某条命令)一旦串行化器收到所有的确认信息,它通知(发送该命令的)客户端该命令已被成功执行, t( w+ S  z# r/ f3 {5 Q1 o7 n
6 X+ t. |+ f& O7 A, A
    补充评论与注解:0 m# e: K; J; X2 P5 Y" M6 [# O

! E8 }" a. J) {+ [% p  V& o- L: N    这个想法有时也被称为主-从复制(Master-SlaveReplication)。
: W# w' j4 l# @) K& {
( k( @/ `' C# V  B0 ~% ~6 l    但是如何处理节点故障呢?很显然,串行化器是一个潜在的单点故障(SinglePointofFailure)。2 b7 ~5 b  Q5 h, H' k

6 A, g* B, W0 |, i% T7 [    我们是否可以构造一个更分布式的方法来解决状态复制?与其直接构造一个一致的命令序列,不如换一个思路:想办法确保在任何时候最多只有一个客户端在发送命令。也就是说,我们采用互斥(MutualExclusion)和各自加锁(RespectivelyLocking)的思想。
: w) R4 _- q6 Z/ P3 s8 b' Y7 G; z8 _
3 Q  p/ ?0 P( g9 }    算法1.10两阶段协议(Two-PhaseProtocol)
; ^0 [: `3 k. y3 \8 o
% |" F: q5 L; n9 F/ y, L    阶段1
( T+ @- e( f$ i! Z
# z! c1 k1 B. `1 r( L( q" D" Z. x8 N6 a    1:客户端向所有的服务器请求锁2 S& u% ~' m1 Z, F- g, ~) F6 \

6 m+ w/ I- O. C8 Q  G* V    阶段2
4 N, E9 z" \1 n; p$ `$ q; z/ I0 ?) m0 u* H
    2:if如果该客户端成功获得了所有服务器的锁then5 R' R0 Z6 @( Q# ]# O* F) R
) o/ B1 @* B6 e, f* d: [
    3:该客户端以可靠的方式向每个服务器发送命令,随即释放锁
+ d9 H! t5 B& J5 ?3 _
3 S7 `. j! a3 q    4:else( A" s4 {( M3 D* V$ ]- l

& ]2 o) I- K9 D" @% ]    5:该客户端释放已经获得的锁$ r8 j/ C6 [: k( o3 x% Q

1 z2 _8 u7 V" U8 L, R* l$ ~7 p    6:该客户端等待一段时间,再重新进入阶段1
' u( t  T% ]7 J* V8 J' X% U
: u8 s. p1 ]3 i0 n: _    7:endif
0 e  D. g( S  G# o6 j, O: ~8 |' m2 R' `
    补充评论与注解:这个想法曾出现在多个领域中,也有着不同的名称,比如两段锁协议(Two-Phase-Locking)(2PL)。
$ c, z8 w( s& q- K
- P! P* k1 r4 Z    另一个例子是两阶段提交协议(Two-PhaseCommit)(2PC),典型场景是数据库系统。第一阶段被称为事物的准备阶段,第二阶段中这个事务或者提交(Committed)或者撤销(回滚)(Aborted)。两阶段提交过程并非由客户端启动,而是在一个被选定的服务器上完成,这个服务器节点通常被称为协调者;
' L4 d& I  ^. I. K
  n( J; t# R  {0 `    一般认为,如果节点可以在宕机之后恢复,较之一个简单的串行化器,2PL和2PC能提供更好的一致性保证。特别对在节点宕机之前就启动的事物来说,存活的节点或许能和宕机的节点保持一致。在使用了一个额外阶段(3PC)的改进版协议中,这个有点更为明显。
4 A, l4 o# a6 Y' _0 W* ?: C  u' R) r3 y$ {0 ]
    2PC和3PC的问题是,他们没有很好地处理异常。' V9 s& J. b1 ?/ h! s7 G+ D
$ i/ ^& |  {0 W) }$ t
    算法1.10真的能很好地应对节点崩溃吗?不是!实际上,它甚至比那个简单的序列器算法(算法1.9)更糟。算法1.9只要求一个节点必须正常工作,但是算法1.10要求所有服务器能够正常响应请求。
. |; I' `3 A3 K/ M$ n, [# v% H
  m: `' j  x) T3 J+ N" _/ y    如果我们仅仅得到一部分服务器的锁,算法1.10能否工作?获得过半数节点的锁是否就足够了?: E& o; k( J6 P

8 q; v. g. ^& \, C1 G! L" D    如果两个或更多的客户端同时企图获得大部分服务器的锁,会发生什么情况?客户端是否必须放弃它们已经获得的锁,以避免死锁?怎么做?如果客户端在释放锁之前就发生故障,又该怎么办?我们是否需要一个与锁稍微不同的概念?5 O4 s- O2 k+ W1 |! a9 k

7 O: A5 \( p# z$ E1 U    Paxos6 g, ?: }1 Z0 m+ A% x6 T
; |/ _( W- B7 E) q7 i9 C
    定义1.11(票(Ticket)).一张票(Ticket)是一个弱化形式的锁,具备下面的性质。4 s% L3 j# K/ Z. A8 g$ j
( H: a2 Y# V& w1 r; U
    可重新发布:一个服务器可以随时发布新的票,哪怕前面发布的票还没有被释放。
8 U& D$ [/ D" V6 J9 g
+ C' |. ~$ e* g9 {3 \# }6 W    票可以过期:当客户端使用一张票t来给服务器发送消息时,仅当t是最新发布的票时,服务器才会接收。
" F, ^6 D6 n, j" Z5 r* n
3 o6 [" ~/ \& |1 ~' l    补充评论与注解:/ s1 t+ W  [  q& p6 @
, K8 @! R, b# j# r$ T
    宕机问题被顺利解决:如果一个客户端在得到一个票之后宕机了,其他的客户端不会受到影响,因为服务器会发布新的票。票可以使用计数器来实现:每当服务器收到一个(发布票的)请求时,将计数器加1。这样当客户端尝试使用某个票时,服务器可以判定该票是否已经过期。
2 _: t+ K' V, K1 A9 P. a
9 h. s3 K0 t  B1 l1 v    我们如何使用票?我们能简单地将算法1.10中的锁用票代替吗?我们需要增加至少一个额外阶段,因为只有客户端知道在阶段2中是否有过半数票是有效的。/ P0 a* j9 p( y3 y# p

* W" J% `; B2 V8 w. K: k    算法1.12朴素的基于票的协议
7 d& j+ @% k% |% U0 ^& g) |: P
1 J) O3 n( U7 x  ]0 I$ y$ h7 I    阶段1+ k8 s6 r+ x+ ^' ]4 W4 f
8 v0 v9 _, V) b8 C' S
    1:客户端向所有的服务器请求一张票
4 p# `$ N  n. _1 d& O
- C- X( V2 M1 P    阶段2$ h2 I* P8 G$ h9 ]6 `* ^; H

; J6 Y( \8 Y* T' r, k    2:if收到过半数服务器的回复then
% O- W  z1 {7 M$ i% p, M  G1 q8 p; y
$ G3 E7 h9 L! F( D    3:客户端将获得的票和命令一起发送给每个服务器
. u9 @  N7 q$ l+ u- {: B% r% L6 D# H* V* E* i( H- C. C  r
    4:服务器检查票的状态,如果票仍然有效,则存储命令并给该客户端一个正反馈消息" b* b% p6 F* L) V# d
' ?+ ]: @( l9 g7 m. k
    5:else1 M4 B* O2 j0 L8 V" |$ X6 P/ z
; H% j7 Z2 `0 |7 T% V2 w* I
    6:客户端等待,并重新进入阶段1
: Q# K! [8 b0 \: ^9 n
4 j& f7 D$ }- g( ?9 {7 f    7:endif+ w5 `7 B, I; F0 T; E

: l/ o  d( ?/ `4 s7 H    阶段3
) H% U/ B5 ^- |  f3 ~0 J
( D9 p* l5 D7 z2 {+ r    8:if客户端从过半数服务器处得到了正反馈then
4 G) y! \; |. Y; v: k" z$ h6 _0 e+ o! i7 t7 d9 j# i6 D, Q
    9:客户端告诉所有的服务器执行之前存储的命令" R' {$ {- r4 V

1 |0 h. l8 m' ?, q! {* F    10:else
8 r! N$ Z+ E9 _  x/ `2 Z% e
; q3 m4 \1 ~( |$ u    11:客户端等待,然后重新进入阶段1
* s1 Q* {7 y' o; H: @5 b2 m/ @2 R7 M& j" I' O
    12:endif
  H0 t( P  G2 K5 j- L. v" S# C5 F" Z
    补充评论与注解:
; p8 C9 u& T$ z1 A: D8 @+ H/ l9 y- T/ B" s
    该算法是有问题的。假设u1是第一个成功地在过半数服务器上存储了命令(c1)的客户端。但是u1很慢,在它告知所有服务器执行命令时(第9行),另一个客户端u2在部分服务器上将命令更新为c2。然后,u1告诉所有的服务器执行所存储的命令。此时,部分服务器将执行c1,而另一部分将执行c2。( n$ x% T, n# T  u, K

7 P8 v' n& w6 C5 G2 {$ b; y( o    如何解决这个问题呢?我们知道如果要修改u1存储在服务器上的命令,u2必须使用比u1更新的票。因此,当u1的票在阶段2被接受后,u2必须在u1在服务器上存储命令(第4行)之后再拿到它的票。8 t, O/ \% s. K

* U6 J+ ]& ], }$ H* D3 R) b! I    一个想法:如果在阶段1中,一个服务器不但发布票,而且也发布它当前所存储的命令。那么u2就知道u1已经存储了命令c1。u2可以不要求服务器存储命令c2,而是继续存储c1。这样,两个客户端都尝试存储和执行相同的命令,那么谁先谁后就不再是一个问题。
& N4 p1 e: w0 `( Q" v5 D1 |  {$ Z. Q3 _8 s- x
    但是,服务器们所存储的命令不一定相同,那么在阶段1,u2就可能从不同的服务器获知了多个不同的命令。它到底应该支持哪一个呢?
9 L+ S$ ]/ O  n+ d! a3 H9 a
0 ?% N$ z# p4 H* m6 z' w9 Y" l; t! U    注意到支持最新存储的命令总是安全的。只要还不存在一个过半数服务器一致支持的命令,客户端们就可以支持任何命令。然而,一旦有一个过半数服务器一致的命令,所有客户端就必须支持这个命令。
. }. V, f0 G: L' x4 n( F4 u% d3 a7 v. N- R
    因此,为了判定哪一个命令是最新存储的,服务器们必须记录存储命令所使用票的编号,并且在阶段1把命令和相应的编号都告诉客户端。
$ b- [9 S% w4 k1 m
. n5 o) l, |5 O4 f8 X% D( w9 P* n( ~    如果每个服务器使用自己的票号,最新的票号就不一定是最大的。如果客户们自己来产生票号,那么这个问题可以解决!$ q/ _1 w! q1 K$ u* j5 d: D
& _' t0 d0 D8 d9 r# {
    算法1.13Paxos
  x. w; q7 c5 Q
" g, ~1 m# B  l- K    客户端(提案者)服务器(接收者)
2 j: F* E* h: Y1 i: l7 J: }% N1 {: S  q6 I# q4 f2 r" W
    初始化.........................................................................5 O% t6 r; y. e5 C6 H
! x7 F  J: d1 v: G( v: }
    c#等待执行的命令#Tmax=0#当前已发布的最大票号4 U) m0 ^# q1 g* Q8 p% U

2 F& S% j% b! e" D7 ]    t=0#当前尝试的票号#+ S6 ]; H" Z( T$ E6 {

5 d& r1 _4 w% w: l0 v! a    C=⊥#当前存储的命令#
  ~+ I" P: t& i; C  V: j9 N9 `2 a! i; P
    Tstore=0#用来存储命令C的票
/ f+ h, _: j  j  {! C
. B6 Z9 u  D. u9 O    阶段1...............................................................................+ t4 t0 ~2 k. M3 i  o: t

8 _* M8 @- ~! t* o9 C! ?( Y    1:t=t+1  G2 k& v# o5 D3 {5 o
' c& l% Y7 d' L8 ~% ^: d
    2:向所有的服务器发消息,请求得到编号为t的票4 o( y: d; _' r$ q

# |/ R6 N8 ]+ W+ Z* }  ~. h6 M5 q    3:ift>Tmaxthen
6 J( D  H6 m: U& Q# O1 |( l9 g7 f( z0 F; @/ B  x2 T/ D' {$ }- {1 d; F
    4:Tmax=t) R5 G0 L( `6 U  `" Y0 W1 N
3 o! _: Y4 H  h2 P
    5:回复:ok(Tstore,C)3 R+ H0 F  p5 ^) B* I+ S# I

% K. ^  B" L$ C5 [, k9 ]    6:endif
! t* v$ u' M4 s( n- \  C- [  B- b% Z9 M  P: }
    阶段2...............................................................................
" S& L9 {4 |1 A* N- z) u! x4 V! w* p5 V, X
    7:if过半数服务器回复okthen
0 @8 ^. ?, N) S6 d
* R0 V  v3 U- E$ k3 Y4 A) ]2 u5 F    8:选择Tstore值最大的(Tstore,C)
+ m+ m8 X% Z9 ]: ~' Y, A5 O* z8 n5 D* ^0 j
    9:ifTstore>0then
% x2 h% K: m$ l* H* d! F7 p
- r6 K# X8 [: Q! o  n1 A    10:c=C
5 Q( [; w# d9 w) \
7 B( y. }& S' f4 }4 Z4 H3 G7 |* u    11:endif
5 Q% p% n# X6 a4 l  d$ p2 h
7 m7 u6 ^7 t3 v    12:向这些回复了ok的服务器发送消息:propose(t,c)9 \: R7 T. b! C
- x& X4 z/ {' g9 n1 h
    13:endif
$ q% X1 s! m6 D
+ \5 K6 }, O) y) v4 m    14:ift=Tstorethen5 i9 F$ e8 c. w6 {1 q

( o' t( D2 W' Y2 g    15:C=c7 \7 W( b5 a8 T4 u& p% ]4 B3 C/ ]

2 W: G+ A# e  p+ d    16:Tstore=t! V2 M; E. \. L( _/ k4 G1 j

7 m7 f. `+ t( N* e+ J/ ?    17:回复:success- B: r2 N2 E  \/ G# j9 z2 d
, _# p0 w9 V8 m  N, ?
    18:endif+ b, B  o5 D  X7 Y$ K1 _0 O: I

2 c! O2 Q& H% y" j* u8 l% P    阶段3...............................................................................5 n$ E! _2 @; r2 X6 E/ o! O+ m* P+ z, u
1 i5 @9 A0 i0 y! Y) C; R8 f0 d. Y& O
    19:if过半数服务器回复successthen9 o( q0 a, U' n7 h# m2 N
, q# |' V# T/ l, J
    20:向每个服务器发送消息:excute(c)4 V5 M- n3 O2 x* ?

! K$ B  w# h/ R5 C0 T3 F& n    21:endif
* b( U2 E1 E( Z. A- q
% z0 @5 y9 a4 P6 m5 a7 ^$ y, }    补充评论与注解:
  S7 K4 ]5 v# q
) Q; ?; t& N0 s0 L9 Z" H* R* i" k    与前面的算法不同,这个算法中没有明确地标出在哪个位置客户端可以跳转到阶段1并且开始新的尝试。实际上这并不是必要的,因为一个客户端可以在算法的任何位置取消当前的尝试并且开始新一轮尝试。这样的方式(不明确标出何时开始新的尝试)让我们不需要操心如何选择何时的超时(timeout)值。我们现在更关心正确性,而正确性和什么时候开始新的尝试是独立的。
( F) H- F% \: I1 m9 j
' X3 e9 |# p- j  K3 d5 f$ h    在阶段1和阶段2,如果票已过期,可以让服务器发送负的反馈,这样可以提高性能。9 z& q$ a0 T2 G+ p; O% n( }
% G4 q; a" @; z7 H4 i
    连续两次尝试之间的等待时间可以用随机函数确认,这样可缓和不同节点之间的竞争。
  X( s; C; l: H! o9 ]) c5 G7 f" Y
    引理1.14.我们将客户端发送的一条消息propose(t,c)(第12行)称为一个内容是(t,c)的提案。如果一项提案(t,c)被存储在过半数服务器上(第15行),则称该提案被选中。如果已经存在一个被选中的propose(t,c),则对于后续每一个propose(t',c'),c'=c将始终成立(t'>t)。
& X2 G$ b9 _' w. |% p# H: b: g/ t( B, `, o" s
    证明。对于每一个票号α,最多只能有一个提案。根据算法(第2行),客户端先向所有服务器发送消息,请求编号为α的票。而只有在收到过半数服务器对编号α的这张票的ok回复之后,客户端才会发送一个提案(第7行)。因此每个提案都可以用它对应的票号α来唯一标识。
4 `9 R, o. A  f) K9 j: q. {2 Q; e. c+ g  T2 |
    下面我们用反证法来证明。假设至少存在一个提案propose(t',c'),满足t'>t且c'≠c。对于这样的提案,我们不妨只考虑那个拥有最小票号的提案,并假设编号为t'。因为propose(t,c)和propose(t',c')都已经被送达了过半数服务器,那么这两个过半数服务器集合之间必然存在一个非空交集S,在S中的服务器都收到了这两个提案。由于propose(t,c)已经被选中,则至少有一个在S中的服务器s已经存储了命令c。注意到当命令c被存储时,票号t仍然是有效的。因此,s必然是存储propose(t,c)之后才收到了关于票号t'的请求,而且该请求使得票号t失效。7 l- [1 S3 G8 {! I' u
) n* c, D& P5 L" C$ K% j' Z" r' O3 _
    于是,发出propose(t',c')的客户端必然已经从s处得知:某个客户端之前已经存储了propose(t,c)。根据算法第8行,每个客户端必须采纳已经存储且具有最高票号的命令,于是该客户端将提议c而不是c'。根据算法,只有一种可能使得该客户端不采纳c:如果该客户端从某个服务器得知另一个提案propose(t*,c*)已经被存储,且c*≠c、t*>t。但是,在这种情况下,一定存在一个客户端已经发送提案propose(t*,c*),且t$ w9 W4 M8 K6 W3 X/ q. U# h+ Q. L

, Z: O+ T- |, K    定理1.15.如果一条命令c被某些服务器执行,那么所有的服务器最终都将执行命令c。0 m# R+ Z! y  i9 f0 G
* H7 S. |2 z3 D% C5 d% }
    证明。根据引理1.14我们得知一旦一个关于包含c的提案被选中,后续的每个提案都将采纳c。由此可见,所有成功的提案都将采纳相同的命令c。这样,只有采纳了命令c的提案会被选中。此外,由于客户端只会在一条命令被选中之后告诉服务器执行该命令(第20行),每个客户端将最终告知所有的服务器执行命令c。; E" y$ L0 R! B9 v( c) {

' j& N; L2 x0 ]6 e5 z  n( H; |) a    补充评论与注解:' W% \& }2 ]9 w" |

' u# I* y) r- K# v    如果拥有第一个成功提案的客户端没有宕机,它将直接告诉所有的服务器执行命令c。: ?/ K+ f! Z  N7 E

% @9 k3 {: x& o1 F. ]    但是,如果客户端在告诉任何一个服务器执行命令之前就宕机了,服务器们将只有等到下一个客户端成功获提案之后才可以执行命令。一旦一个服务器接收到一个请求去执行命令,它可以通知所有后面到达的客户端:已经有一条命令被选中了。这样客户端就可以避免(再向这个服务器)继续发送提案。
/ `7 O7 t' D* r- D# e
7 ~2 s0 D/ h% o$ |$ h6 v" s, F9 \0 E    如果超过一半的服务器宕机,Paxos将不能工作。因为客户端不能再取得过半数服务器认可。
7 d0 E; i+ t% @; [, [7 c: Q# B( O$ j0 H5 f' L, N
    最初版本的Paxos包含三个角色:提案者、接受者,以及学习者。学习者不做任何事情,只是从其他节点学习哪个命令被选中了。
/ ]5 i5 z# W. o( E! O& D- c  c6 ?
9 k/ V( c: E" w  j    我们只让每个节点承担一个角色。在某些场景下,一个节点可能承担多个角色。比如,在一个P2P的场景下,每个节点既是服务器又是客户端。
( g( ]' t7 Q9 R" X6 s& W! x) _& C; s; T# X. ~
    上述算法必须信任客户端们(提案者们)会严格遵守协议。然而,这个假设在很多场景下并不合理。在某些场景下,提案者的角色可以被一组服务器承担,客户端们需要联络提案者,并用它们的名义来发布提案。: M9 |: \9 a+ y' L7 `
* C3 B& F6 `7 t, z
    到现在为止,我们仅仅讨论了如何通过Paxos来使一组节点达成一致性决议(decision)来执行一条命令。单独的一条决议被称为Paxos的一个实例(instance)。
2 T* Y2 b: j2 X
8 T* Z* p  z; I    如果希望执行多条命令,我们可以给每个实例附加一个实例编号。在每条消息中,该实例编号都会被使用。一旦某条命令被选中,任何一个客户端都可以采用一个新的实例编号启动一个新的实例。如果一个服务器不知道前面的一个实例已经有了一个一致决议,那么该服务器可以询问其他服务器决议的内容。
9 g2 B5 @; h% {  l- h# {  H! Q1 y4 `
9 x+ p# F, F" u; o) k    【延伸阅读】Paxos算法的来历
/ ?% u& o3 g6 r( \) V! H( _! m4 f1 n( u# T6 s: `
    LeslieLamport在1989年提出了Paxos。但是,“Paxos”这个名字是怎么来的呢?Lamport在论文中描述了一个虚拟的希腊小岛——Paxos,并假定这个算法是为了解决在岛上的议会中的投票问题。他非常喜欢这个想法,甚至以一个印第安纳·琼斯风格的考古学家的身份做过几个报告。当论文第一次投稿的时候,大多数评委都对这个议会故事感到困惑,无法理解算法的目的和思想。论文因此被拒绝发表!: R/ v4 E, A) p4 y$ ~
, i/ @8 Z  D& d0 T  T7 v
    Lamport拒绝修改论文,稍后他表示“不开心,因为这个领域的学者如此缺乏幽默感”。: ]( s* e; h. i
* v4 N6 a; S: K+ A+ B% ^( M7 Z7 J: l
    几年之后,随着应用的发展,Paxos协议的用途变得更加广泛。Lamport于是从抽屉里翻出这篇被拒绝的论文,并发给他的几位同事。这些同事们都表示很喜欢这个想法。于是Lamport决定重新投稿。和8年前的初稿相比,论文基本没改!但是这次论文被录用了。
标签: 算法
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

救世主在哪儿 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    7