paxos算法

看过很多前辈写 Paxos 协议，讲得挺详细的，本文通过描述实际的状态变化，帮助大家更直观的理解 Paxos 协议，盼交流

1. 现状：

发起者：
Proposer
接收者：
AcceptorOne(accepted_n = 3);
AcceptorTwo(accepted_n = 5);
AcceptorThree(accepted_n = 7);
AcceptorFour(accepted_n = 0);

2. 过程：

我们用 n 表示变量
我们用 suggest_ 做前缀表示是由 Proposer 发起的建议值 (为了便于理解， 本文"suggest_n" 变量仅存在于 Proposer 发起方)。
我们用 recieved_ 做前缀表示 Acceptor 收到的建议值 (为了便于理解， 本文 “recieved_n” 变量仅存在于 Acceptor 接受方)。
我们用 promise_n 表示承诺的条件阈值。

第一步
Proposer 选择一个提议编号 suggest_n = 6，向所有的 Acceptor 广播（suggest_n = 6）请求，所以状态如下：
发起者：
Proposer（suggest_n = 6，suggest_content = “sth”），所有的接受者收到请求后：
接收者：
AcceptorOne(recieved_n =6, recieve_content = “sth”, accepted_n = 3);
AcceptorTwo(recieved_n =6, recieve_content = “sth”,accepted_n = 5);
AcceptorThree(recieved_n =6, recieve_content = “sth”,accepted_n = 7);
AcceptorFour(recieved_n =6, recieve_content = “sth”,accepted_n = 0);

第二步
Acceptor 接收到 （suggest_n = 6）请求后，会拿到这个 n 自己先前就持有的 accepted_n 做比较：
如果 recieved_n > accepted_n 则变更 accepted_n = 6，并且不会再接收其他提议编号比 6 小的提议，
否则抛弃本次建议不做处理， 由此得到以下算式：
6 > 3（记录 promise_n = 6，并做出承诺：只接受大或者等于 promise_n 的 suggest_n ）;
6 > 5（记录 promise_n = 6，并做出承诺：只接受大或者等于 promise_n 的 suggest_n ）;
6 < 7（不承诺）;
6 > 0（记录 promise_n = 6，并做出承诺：只接受大或者等于 promise_n 的 suggest_n ）;
=> 得到
AcceptorOne(recieved_n=6, accepted_n = 3，promise_n = 6, recieve_content = “sth”,);
AcceptorTwo(recieved_n=6, accepted_n = 5，promise_n = 6, recieve_content = “sth”,);
AcceptorThree(accepted_n = 7);
AcceptorFour(recieved_n=6, accepted_n = 0，promise_n = 6, recieve_content = “sth”,);
此时 AcceptorOne、AcceptorTwo 、AcceptorFour 向 Proposer 承诺：不再接受比 6 小的提议了， 只接受大于或等于 6 的提议。

第三步
Proposer 得到了超过半数的 Acceptor 的承诺后，
如果所有的 Acceptor 都没有接受（not accepted），便会再次向所有的 Acceptor 发起自己的值和提议编号 （suggest_n = 6），Acceptor 接收到提议后，如果该提议编号 suggest_n 不违反自己做过的承诺 (要求suggest_n >= promise_n)，则接受该提议。
如果存在已接受的(accepted)，则从所有接受过的值中选择对应的提议编号最大的，由于前面的案例中，我们以单交互为例子说明，因此 最终会得到 n=6，即所有的 Acceptor 都接受了 Proposer (suggest_n=6) 的选举请求

基于以上过程，我们已经可以再继续推演出 多个 Proposer 发起的提议， 即一个 Acceptor 实际上可能会收到多个提议，如下：
AcceptorOne(recieved_n=[1, 3, 5, 6], accepted_n = 3，promise_n = 6);
AcceptorTwo(recieved_n=[1, 3, 9], accepted_n = 5，promise_n = 9);
AcceptorFour(recieved_n=[2, 8, 11], accepted_n = 0，promise_n = 11);
最终会有如下响应：
AcceptorOne->Ack(promise_n = 6, value=one);
AcceptorTwo->Ack(accepted_n = 9，value=two);
AcceptorFour->Ack(accepted_n = 11，value=three);
至此所有的 Proposer 都会拿到 [6, one] [9, two] [11, three] 三组数据，最终选举出目标为 11，

确认 11 的这个过程，并不一定是同时会拿到 6, 9 11 再一起做比较，它实际上有可能会有时序存在的，但是最终一定会得到一个最终解