Paxos Made Simple

\space

Acquirement 收获

\space

1. Consensus protocol & Consistency model comparison

共识协议：由众多参与者对某项内容达成共识，如：共识协议：由众多参与者对某项内容达成共识，如：共识协议：由众多参与者对某项内容达成共识，如：
在分布式环境下，多进程通过一定规则，对某项内容达成共识。在分布式环境下，多进程通过一定规则，对某项内容达成共识。在分布式环境下，多进程通过一定规则，对某项内容达成共识。

一致性模型：侧重于内容在时间顺序上的统一，如：一致性模型：侧重于内容在时间顺序上的统一，如：一致性模型：侧重于内容在时间顺序上的统一，如：
何时when能读取更新，是存储器和程序的协议。何时when能读取更新，是存储器和程序的协议。何时when能读取更新，是存储器和程序的协议。
\space

2. Two-phase consensus algorithm

通过对proposer、acceptor两个角色在phase1、phase2的行动限定，规定了这样一个共识算法。通过对proposer、acceptor两个角色在phase \space 1、phase \space 2的行动限定，规定了这样一个共识算法。通过对proposer、acceptor两个角色在phase 1、phase 2的行动限定，规定了这样一个共识算法。
并引入learner用来学习已被choose的value。算法的简述和详细推导过程都将下面给出。并引入learner用来学习已被choose的value。算法的简述和详细推导过程都将下面给出。并引入learner用来学习已被choose的value。算法的简述和详细推导过程都将下面给出。
\space

3. A state machine with Paxos’s consensus algorithm

将共识算法引入一个由多个client、多个独立运行状态机的server构成的分布式系统中。将共识算法引入一个由多个client、多个独立运行状态机的server构成的分布式系统中。将共识算法引入一个由多个client、多个独立运行状态机的server构成的分布式系统中。
保证多个server可以执行一个相同的command序列。保证多个server可以执行一个相同的command序列。保证多个server可以执行一个相同的command序列。
\space

Introdunction 引言

\space

1. The first section shows that this consensus algorithm follows almost unavoidably from the properties we want it to satisfy.

(首先会介绍实现这个二阶段共识算法，及需要满足的属性。)(首先会介绍实现这个二阶段共识算法，及需要满足的属性。)(首先会介绍实现这个二阶段共识算法，及需要满足的属性。)

2. The second section explains the complete Paxos algorithm, which is obtained by the straightforward application of consensus to the state machine approach for building a distributed system.

(最后展现这样一个完整的Paxos算法：通过将共识直接应用到构成分布式系统的状态机上。)(最后展现这样一个完整的Paxos算法：通过将共识直接应用到构成分布式系统的状态机上。)(最后展现这样一个完整的Paxos算法：通过将共识直接应用到构成分布式系统的状态机上。)

\space

The Consensus Algorithm 共识算法

\space

The Problem 算法假设与问题

1. Assumption for question 待解决问题假设

#1 Assume a collection of processes that can propose values.
(假设由一群可以propose值的进程。)(假设由一群可以propose值的进程。)(假设由一群可以propose值的进程。)

#2 A consensus algorithm ensures that a single one among the proposed values is chosen.
(共识算法确保在被propose的值中只有一个值可以被choose。)(共识算法确保在被propose的值中只有一个值可以被choose。)(共识算法确保在被propose的值中只有一个值可以被choose。)

#3 If no value is proposed, then no value should be chosen.
(如果没有值被propose，则没有值被choose。)(如果没有值被propose，则没有值被choose。)(如果没有值被propose，则没有值被choose。)

#4 If a value has been chosen, then processes should be able to learn the chosen value.
(如果一个值已经被choose，那么进程们可以学到这个被choose的值。)(如果一个值已经被choose，那么进程们可以学到这个被choose的值。)(如果一个值已经被choose，那么进程们可以学到这个被choose的值。)
\space

2. Safety requirement for consensus 共识算法安全需求

#1 Only a value that has been proposed may be chosen.
(只有被propose的值可以被choose。)(只有被propose的值可以被choose。)(只有被propose的值可以被choose。)

#2 Only a single value is chosen.
(只有一个值被choose。)(只有一个值被choose。)(只有一个值被choose。)

#3 A process never learns that a value has been chosen unless it actually has been.
(在一个值被确定choose之前，进程不会学到值。)(在一个值被确定choose之前，进程不会学到值。)(在一个值被确定choose之前，进程不会学到值。)
\space

3. Assumption for implemention 共识算法实行假设

#1 We let the three roles in the consensus algorithm be performed by three classes of agents: proposers, acceptors, and learners，a single process may act as more than one agent.
(我们使用proposer、acceptor、learner这三种agent来代表共识算法中的三种角色。)(我们使用proposer、acceptor、learner这三种agent来代表共识算法中的三种角色。)(我们使用proposer、acceptor、learner这三种agent来代表共识算法中的三种角色。)
(在实现中，单机可以扮演多个agent。)(在实现中，单机可以扮演多个agent。)(在实现中，单机可以扮演多个agent。)

#2 Agents can communicate with one another by sending messages.
(agent之间通过发送message来通信。)(agent之间通过发送message来通信。)(agent之间通过发送message来通信。)

#3 We use the customary asynchronous, non-Byzantine model, in which:
(我们使用一种异步、非拜占庭的模型，会产生以下问题：)(我们使用一种异步、非拜占庭的模型，会产生以下问题：)(我们使用一种异步、非拜占庭的模型，会产生以下问题：)
\space

4. Problem for this implemention 实行模型问题

#1 Agents operate at arbitrary speed, may fail by stopping, and may restart. Since all agents may fail after a value is chosen and then restart, a solution is impossible unless some information can be remembered by an agent that has failed and restarted.
(agent以一种任意速度运行，且可能因为停止和重启而发生错误。由于agent可能在值选择之后重启，)(agent以一种任意速度运行，且可能因为停止和重启而发生错误。由于agent可能在值选择之后重启，)(agent以一种任意速度运行，且可能因为停止和重启而发生错误。由于agent可能在值选择之后重启，)
(除非有方法可以保存已有信息，不然会丢失已选择值。)(除非有方法可以保存已有信息，不然会丢失已选择值。)(除非有方法可以保存已有信息，不然会丢失已选择值。)

#2 Messages can take arbitrarily long to be delivered, can be duplicated, and can be lost, but they are not corrupted.
(message可以任意长，可以被传递、被复制、丢失、但内容不能出错。)(message可以任意长，可以被传递、被复制、丢失、但内容不能出错。)(message可以任意长，可以被传递、被复制、丢失、但内容不能出错。)

\space

Single acceptor 单accpetor选值算法推导

The easiest way to choose a value is to have a single acceptor agent. A proposer sends a proposal to the acceptor, who chooses the first proposed value that it receives. Although simple, this solution is unsatisfactory because the failure of the acceptor makes any further progress impossible.
(最简单的选值模型是只有一个acceptor：一个proposer发送一个proposal给唯一acceptor，acceptor会选择第一个)(最简单的选值模型是只有一个acceptor：一个proposer发送一个proposal给唯一acceptor，acceptor会选择第一个)(最简单的选值模型是只有一个acceptor：一个proposer发送一个proposal给唯一acceptor，acceptor会选择第一个)
(被propose的值。虽然非常简单，但是当唯一acceptor出错时，值会被遗忘。)(被propose的值。虽然非常简单，但是当唯一acceptor出错时，值会被遗忘。)(被propose的值。虽然非常简单，但是当唯一acceptor出错时，值会被遗忘。)

\space

Multiple acceptor 多acceptor选值算法推导

Instead of a single acceptor, let’s use multiple acceptor agents. A proposer sends a proposed value to a set of acceptors. An acceptor may accept the proposed value. The value is chosen when a large enough set of acceptors have accepted it.

(使用多acceptor模型：当一个proposer发送一个proposal给一个acceptor集。每个acceptor可以accept被propose的value。)(使用多acceptor模型：当一个proposer发送一个proposal给一个acceptor集。每个acceptor可以accept被propose的value。)(使用多acceptor模型：当一个proposer发送一个proposal给一个acceptor集。每个acceptor可以accept被propose的value。)
(当足够多的acceptor已经accept了同一个值，这个值就会被choose。)(当足够多的acceptor已经accept了同一个值，这个值就会被choose。)(当足够多的acceptor已经accept了同一个值，这个值就会被choose。)

Two-Phase Algorithm 多acceptor选值的两阶段算法

Phase1.\ Phase1.\space Phase1.

(a) A proposer selects a proposal number n and sends a prepare request with number n to a majority of acceptors.

proposer选取number为n的proposal，并向多数acceptor发送带有这个proposal的prepare请求。proposer选取number为n的proposal，并向多数acceptor发送带有这个proposal的prepare请求。proposer选取number为n的proposal，并向多数acceptor发送带有这个proposal的prepare请求。

(b) If an acceptor receives a prepare request with number n greater than that of any prepare request to which it has already responded, then it responds to the request with a promise not to accept any more proposals numbered less than n and with the highest-numbered proposal (if any) that it has accepted.

当acceptor收到一个prepare请求，其proposal的number大于任何一个已回复的number；当acceptor收到一个prepare请求，其proposal的number大于任何一个已回复的number；当acceptor收到一个prepare请求，其proposal的number大于任何一个已回复的number；
那么回复一个协议：不会再接受任何一个小于这个proposal的number的proposal；那么回复一个协议：不会再接受任何一个小于这个proposal的number的proposal；那么回复一个协议：不会再接受任何一个小于这个proposal的number的proposal；
并回复一个已接受到的number最大的proposal（为了它的value）。并回复一个已接受到的number最大的proposal（为了它的value）。并回复一个已接受到的number最大的proposal（为了它的value）。

Phase2.\ Phase2.\space Phase2.

(a) If the proposer receives a response to its prepare requests (numbered n) from a majority of acceptors, then it sends an accept request to each of those acceptors for a proposal numbered n with a value v, where v is the value of the highest-numbered proposal among the responses, or is any value if the responses reported no proposals.

当proposer收到多数acceptor的回复。会发送一个accept请求，这次的proposal带上了value，来自回复中的number当proposer收到多数acceptor的回复。会发送一个accept请求，这次的proposal带上了value，来自回复中的number当proposer收到多数acceptor的回复。会发送一个accept请求，这次的proposal带上了value，来自回复中的number
最大值的proposal；当没有proposal，则proposal自己选取一个value。最大值的proposal；当没有proposal，则proposal自己选取一个value。最大值的proposal；当没有proposal，则proposal自己选取一个value。

(b) If an acceptor receives an accept request for a proposal numbered n, it accepts the proposal unless it has already responded to a prepare request having a number greater than n.

当acceptor接受到了accept请求，且在acceptor已回复的prepare请求的proposal中，当acceptor接受到了accept请求，且在acceptor已回复的prepare请求的proposal中，当acceptor接受到了accept请求，且在acceptor已回复的prepare请求的proposal中，
没有大于当前accept请求number的proposal，则accept。没有大于当前accept请求number的proposal，则accept。没有大于当前accept请求number的proposal，则accept。

\space

接下来是上述算法由来的推导简述：

1. 为了解决acceptor的large enough问题，提出了majority of acceptors的概念：

P0.有多数acceptor接受一个value时，选择这个value。\ P0.\space有多数acceptor接受一个value时，选择这个value。 P0. 有多数acceptor接受一个value时，选择这个value。

2. 为了确保acceptor能选出value，满足这样一个需求：

P1.acceptor一定能accept到proposer发出的第一个proposal。\space \ P1.\space acceptor一定能accept到proposer发出的第一个proposal。 P1. acceptor一定能accept到proposer发出的第一个proposal。

3. 由于一个proposal只有一个value，当同一时间不同proposal发出不同proposal时，有可能出现难以选出value的情况。于是将proposal设置为一个number和一个value的二元组。并满足：

P2.当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被choose，其value必须\ P2.\space当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被choose，其value必须 P2. 当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被choose，其value必须与前者一致。与前者一致。与前者一致。

4. 由于一个已被choose的value，肯定被acceptor接受过，则满足：

P2a.当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被acceptor所accept，\ P2^{a}.\space 当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被acceptor所accept， P2a. 当一个number为n的proposal，其value已被choose。则number大于n的proposal若要被acceptor所accept，其value必须与前者一致。其value必须与前者一致。其value必须与前者一致。

5. 由于异步通信的原因，可能有acceptor不需要accept，某个value已经选出来了。此时某个proposal再issue一个proposal过来，这个proposal的number大于已选的number，value却不同。根据P1\ P1 P1，这个acceptor应该接受。但如果接受，则违背P2a\ P2^{a} P2a。于是需要满足:

P2b.当一个number为n的proposal，其value已被choose。则number大于n的proposal\ P2^{b}.\space当一个number为n的proposal，其value已被choose。则number大于n的proposal P2b. 当一个number为n的proposal，其value已被choose。则number大于n的proposal 若要被proposal所issue，其value必须与前者一致。若要被proposal所issue ，其value必须与前者一致。若要被proposal所issue，其value必须与前者一致。

6. 为了通过归纳证明P2b\ P2^{b} P2b中，已issue的值与已提交的相同，需要满足：

P2c.若已issue的number为n，值为v的proposal要与已提交的v一致。则多数acceptors要么满足没有number小于\ P2^{c}. \space 若已issue的number为n，值为v的proposal要与已提交的v一致。则多数acceptors要么满足没有number小于 P2c. 若已issue的number为n，值为v的proposal要与已提交的v一致。则多数acceptors要么满足没有number小于 n的proposal，要么满足number小于n的proposal中，number最高的proposal的value为v。n的proposal，要么满足 number小于n的proposal中，number最高的proposal的value为v。n的proposal，要么满足number小于n的proposal中，number最高的proposal的value为v。

7. 为了保持P2c\ P2^{c} P2c 不变性，需要让proposal、acceptor满足一定的算法（其中为了acceptor保存尽量少的信息，对其保存的信息进行了优化。）

Proposer:
当其选择了一个number为n的新proposal发给所有acceptor，首先会让acceptor签订协议（不再接受number<n的proposal），随后acceptor将已接受的、最大number的proposal回应给proposer。——prepare request；

当proposer收到大多数的response，issue这个带有值v,number为n的proposer。v为response中最大number的proposal或者自选。——accept request。

Acceptor：
需要选择性回应prepare和accept的request。其中prepare均回应。而accept回应需要满足要求：

P1a.若要接受acceptrequest(proposaln)，那么之前已回应的preparerequest中的proposal的number不能大于n。\ P1^{a}.\space 若要接受accept request(proposal n)，那么之前已回应的prepare request中的proposal的number不能大于n。 P1a. 若要接受acceptrequest(proposaln)，那么之前已回应的preparerequest中的proposal的number不能大于n。

Optimization:为了让acceptor防止宕机而保存信息只保存 已接受的number最高的proposal、已回复request请求中的number最高的proposal。提出以下优化：
当acceptor已经对proposal n+1回应，那么不再接受<n+1的proposal。即，prepare n 会被忽略；
同样，已接受的proposal，再有prepare request也会被忽略。

8. 结合了proposal、acceptor的行动过程，最终得到了上述的二阶段算法。

\space

接下来是上述算法由来的推导详述：

\space

Question 1:How large is large enough? →\rightarrow→ (问题1：多少个acceptor算足够多呢？)(问题1：多少个acceptor算足够多呢？)(问题1：多少个acceptor算足够多呢？)

P0.\ P0.\space P0. A value is chosen only when it is accepted by a majority of acceptors.→\rightarrow→ (任意的大部分就算足够多。)(任意的大部分就算足够多。)(任意的大部分就算足够多。)

Question 2:How can we ensure that a value to be chosen even if only one value is proposed by a single proposer?

(问题2：怎么保证就算只有一个value被propose，也能让这个value被choose呢？)(问题2：怎么保证就算只有一个value被propose，也能让这个value被choose呢？)(问题2：怎么保证就算只有一个value被propose，也能让这个value被choose呢？)

P1.\ P1.\space P1. An acceptor must accept the first proposal that it receives.→\rightarrow→ (acceptor必须accept第一个接受的proprosal。)(acceptor必须accept第一个接受的proprosal。)(acceptor必须accept第一个接受的proprosal。)

Question 3:Several values could be proposed by different proposers at about the same time, leading to a situation in which every acceptor has accepted a value, but no single value is accepted by a majority of them.

(问题3：在同一时间可能有多个value被不同的proposer所propose，这可能导致acceptor虽然accept了value)(问题3：在同一时间可能有多个value被不同的proposer所propose，这可能导致acceptor虽然accept了value)(问题3：在同一时间可能有多个value被不同的proposer所propose，这可能导致acceptor虽然accept了value)
(却无法形成多数acceptor集，choose出唯一value。如：2个value被4个acceptor平分，难以决出value。)(却无法形成多数acceptor集，choose出唯一value。如：2个value被4个acceptor平分，难以决出value。)(却无法形成多数acceptor集，choose出唯一value。如：2个value被4个acceptor平分，难以决出value。)
\space

为了解决问题3，提出以下假设和设定：

1. P1 and P0 imply that an acceptor must be allowed to accept more than one proposal.

(由P0和P1可以推出：acceptor是允许accept多个proposal的。)(由P0和P1可以推出：acceptor是允许accept多个proposal的。)(由P0和P1可以推出：acceptor是允许accept多个proposal的。)

2. A proposal consists of a unique proposal number and a value.

(假设proposal由一个唯一的number和一个值构成。)(假设proposal由一个唯一的number和一个值构成。)(假设proposal由一个唯一的number和一个值构成。)

3. A value is chosen when a single proposal with that value has been accepted by a majority of the acceptors.

(当proposal被多数acceptor所accept，其对应的value被choose。)(当proposal被多数acceptor所accept，其对应的value被choose。)(当proposal被多数acceptor所accept，其对应的value被choose。)

4. We can allow multiple proposals to be chosen, but we must guarantee that all chosen proposals have the same value.

(允许多个proposal被choose，但保证其中的value相同。)(允许多个proposal被choose，但保证其中的value相同。)(允许多个proposal被choose，但保证其中的value相同。)

通过之后将推导的一系列对number的归纳后，足以保证：

P2.\ P2.\space P2. If a proposal with value v is chosen, then every higher-numbered proposal that is chosen has value v.
(如果一个值为v的proposal已被choose，那么任何已被choose且比它number高的proposal其值也只能是v。)(如果一个值为v的proposal已被choose，那么任何已被choose且比它number高的proposal其值也只能是v。)(如果一个值为v的proposal已被choose，那么任何已被choose且比它number高的proposal其值也只能是v。)
\space

由于一个已被choose的proposal至少被一个acceptor所accept，我们可以通过满足以下需求来满足P2：

P2a.\ P2^{a}.\space P2a. If a proposal with value v is chosen, then every higher-numbered proposal accepted by any acceptor has value v.
(如果一个值为v的proposal已被choose，那么acceptor已经accept的每一个大于已选proposalnumber)(如果一个值为v的proposal已被choose，那么acceptor已经accept的每一个大于已选proposal \space number)(如果一个值为v的proposal已被choose，那么acceptor已经accept的每一个大于已选proposal number)
(的proposal其value必须为v。)(的proposal其value必须为v。)(的proposal其value必须为v。)
\space

接下来考虑异步的情况：

We still maintain P1\ P1 P1 to ensure that some proposal is chosen.
(我们依旧通过P1确保proposal可以被choose。)(我们依旧通过P1确保proposal可以被choose。)(我们依旧通过P1确保proposal可以被choose。)
Because communication is asynchronous, a proposal could be chosen with some particular acceptor c never having received any proposal.
(由于异步通信，proposal可以在一些acceptor从未收到proposal的情况下被choose。)(由于异步通信，proposal可以在一些acceptor从未收到proposal的情况下被choose。)(由于异步通信，proposal可以在一些acceptor从未收到proposal的情况下被choose。)
Suppose a new proposer “wakes up” and issues a higher-numbered proposal with a different value.
(而当一些proposer刚启动，会issue一个比已选proposal的number更高的number，)(而当一些proposer刚启动，会issue一个比已选proposal的number更高的number，)(而当一些proposer刚启动，会issue一个比已选proposal的number更高的number，)
(且其value与已选value不同。)(且其value与已选value不同。)(且其value与已选value不同。)
P1\ P1 P1 requires c to accept this proposal, violating P2a\ P2^{a} P2a.
(但是根据P1，acceptor依旧会accept它。却违反了P2a。)(但是根据P1，acceptor依旧会accept它。却违反了P2^{a}。)(但是根据P1，acceptor依旧会accept它。却违反了P2a。)

为了解决这个冲突，通过满足以下需求：

P2b.\ P2^{b}.\space P2b. If a proposal with value v is chosen, then every higher-numbered proposal issued by any proposer has value v.
(如果一个值为v的proposal已被choose，那么已经issue的每一个大于已选proposalnumber)(如果一个值为v的proposal已被choose，那么已经issue的每一个大于已选proposal \space number)(如果一个值为v的proposal已被choose，那么已经issue的每一个大于已选proposal number)
(的proposal其value必须为v。)(的proposal其value必须为v。)(的proposal其value必须为v。)
\space

为了寻找满足P2b\ P2^{b} P2b的办法，先证明其合理性：

1. We would assume that some proposal with number m and value v is chosen and show that any proposal issued with number n > m also has value v.

(假设已选proposal其number为m，值为v。且任意多值同样为v，number为n>m的proposal被issue。)(假设已选proposal其number为m，值为v。且任意多值同样为v，number为n>m的proposal被issue。)(假设已选proposal其number为m，值为v。且任意多值同样为v，number为n>m的proposal被issue。)

2. For the proposal numbered m to be chosen, there must be some set C consisting of a majority of acceptors such that every acceptor in C accepted it.

(对于即将被选的proposal，一定有多数acceptor已accept了它的value，组成setC。)(对于即将被选的proposal，一定有多数acceptor已accept了它的value，组成set C。)(对于即将被选的proposal，一定有多数acceptor已accept了它的value，组成setC。)

3. Assumption that every proposal issued with a number in m . .(n − 1) has value v.

(假设每个被issue的proposal，其number有m到n−1，且值均为v。)(假设每个被issue的proposal，其number有m到n-1，且值均为v。)(假设每个被issue的proposal，其number有m到n−1，且值均为v。)

通过上述假设可以推出：

Every acceptor in C has accepted a proposal with number in m . .(n − 1), and every proposal with number in m . . (n − 1) accepted by any acceptor has value v.
(每个setC中的acceptor已经accept了number从m到n−1的proposal，这是由于P1;)(每个setC中的acceptor已经accept了number从m到n-1的proposal，这是由于P1;)(每个setC中的acceptor已经accept了number从m到n−1的proposal，这是由于P1;)
(每个已被accept的number从m到n−1的proposal,其值均为v，这是由于上述假设3。)(每个已被accept的number从m到n-1的proposal,其值均为v，这是由于上述假设3。)(每个已被accept的number从m到n−1的proposal,其值均为v，这是由于上述假设3。)
\space

为了完成整个归纳，通过满足以下需求的不变性来满足number为n的proposal其值为v：

P2c.\ P2^{c}.\space P2c. For any v and n, if a proposal with value v and number n is issued, then there is a set S consisting of a majority of acceptors such that either (a) no acceptor in S has accepted any proposal numbered less than n, or (b) v is the value of the highest-numbered proposal among all proposals numbered less than n accepted by the acceptors in S.

(对于一个已经issue的number为n，value为v的proposal。其多数acceptor集S有以下两种情况：)(对于一个已经issue的number为n，value为v的proposal。其多数acceptor集S有以下两种情况：)(对于一个已经issue的number为n，value为v的proposal。其多数acceptor集S有以下两种情况：)
(a:这个集中，已accept的proposal中，没有number小于n的。)(a:这个集中，已accept的proposal中，没有number小于n的。)(a:这个集中，已accept的proposal中，没有number小于n的。)
(b:这个集中，number小于n的proposal中，number最高的proposal其值为v。)(b:这个集中，number小于n的proposal中，number最高的proposal其值为v。)(b:这个集中，number小于n的proposal中，number最高的proposal其值为v。)

至此可以发现：P2c\ P2^{c} P2c →\rightarrow→P2b\ P2^{b} P2b →\rightarrow→ P2a\ P2^{a} P2a →\rightarrow→ P2\ P2 P2。为了满足P2c\ P2^{c} P2c 的不变性，必须要设法得知最大number的proposal，有以下两种可能：

Learning about proposals already accepted is easy enough.
(已经接受到的proposal，很容易得知。)(已经接受到的proposal，很容易得知。)(已经接受到的proposal，很容易得知。)
Instead of trying to predict the future,the proposer requests that the acceptors not accept any more proposals numbered less than n.
(未来才能接受到的proposal很难得知。proposal通过发出向acceptor发出request的方式)(未来才能接受到的proposal很难得知。proposal通过发出向acceptor发出request的方式)(未来才能接受到的proposal很难得知。proposal通过发出向acceptor发出request的方式)
(避免接受那些小于number为n的proposal。)(避免接受那些小于number为n的proposal。)(避免接受那些小于number为n的proposal。)

以下是针对proposal的算法，以便设法得知最大number：

1. A proposer chooses a new proposal number n and sends a request to each member of some set of acceptors, asking it to respond with:

(一个number为n的proposal被proposer发向某个多数set的每个acceptor：)(一个number为n的proposal被proposer发向某个多数set的每个acceptor：)(一个number为n的proposal被proposer发向某个多数set的每个acceptor：)

（a） A promise never again to accept a proposal numbered less than n, and
达成一个协议：不会接受一个比number为n更小的proposal。达成一个协议：不会接受一个比number为n更小的proposal。达成一个协议：不会接受一个比number为n更小的proposal。

（b) The proposal with the highest number less than n that it has accepted, if any.
acceptor返回一个number比n小、已接受的acceptor中最大的number给proposer。acceptor返回一个number比n小、已接受的acceptor中最大的number给proposer。acceptor返回一个number比n小、已接受的acceptor中最大的number给proposer。

（c） I will call such a request a prepare request with number n.
这个request被成为preparerequest。这个request被成为prepare request。这个request被成为preparerequest。

2. If the proposer receives the requested responses from a majority of the acceptors, then it can issue a proposal with number n and value v, where v is the value of the highest-numbered proposal among the responses, or is any value selected by the proposer if the responders reported no proposals. Let’s call this an accept request.

(如果多数acceptor已经接受到了prepare请求的回应，proposer就可以issue这个number为n的proposal。)(如果多数acceptor已经接受到了prepare 请求的回应，proposer就可以issue这个number为n的proposal。)(如果多数acceptor已经接受到了prepare请求的回应，proposer就可以issue这个number为n的proposal。)
(其值从回应中最大number的proposal中取，或者没有proposal时proposer自取。我们把这个)(其值从回应中最大number的proposal中取，或者没有proposal时proposer自取。我们把这个)(其值从回应中最大number的proposal中取，或者没有proposal时proposer自取。我们把这个)
(issue给acceptor的请求成为acceptrequest。)(issue给acceptor的请求成为accept \space request。)(issue给acceptor的请求成为accept request。)

以上是针对proposal的算法，以下介绍何时acceptor可以接受请求：

1. It can always respond to a prepare request.

(acceptor总可以回应一个prepare请求。)(acceptor总可以回应一个prepare请求。)(acceptor总可以回应一个prepare请求。)

2. It can respond to an accept request, accepting the proposal, iff it has not promised not to. In other words:

(acceptor可以回复accept请求，只要这个proposal没有因协议限制接受：)(acceptor可以回复accept请求，只要这个proposal没有因协议限制接受：)(acceptor可以回复accept请求，只要这个proposal没有因协议限制接受：)

P1a.\ P1^{a}.\space P1a. An acceptor can accept a proposal numbered n iff it has not responded to a prepare request having a number greater than n.
(acceptor可以接受一个number为n的proposal：当没有一个number大于n的proposal在prepare请求中被回复。)(acceptor可以接受一个number为n的proposal：当没有一个number大于n的proposal在prepare请求中被回复。)(acceptor可以接受一个number为n的proposal：当没有一个number大于n的proposal在prepare请求中被回复。)

\space

可以发现：P1\ P1 P1 ∈\in∈ P1aP1^{a}P1a 。为了让acceptor在重启以后保持P2cP2^{c}P2c的不变性，需要让acceptor保存一些相关信息。为了只保存已接受的最高number的proposal、已回复request请求的最高number的proposal,实施了以下的优化：

1. Suppose an acceptor receives a prepare request numbered n, but it has already responded to a prepare request numbered greater than n, thereby promising not to accept any new proposal numbered n.

(假设acceptor已经回复了一个prepare请求，其number大于n，那么它不应该接受number为n的proposal。)(假设acceptor已经回复了一个prepare请求，其number大于n，那么它不应该接受number为n的proposal。)(假设acceptor已经回复了一个prepare请求，其number大于n，那么它不应该接受number为n的proposal。)
(此时acceptor收到了一个prepare请求，其number为n，那么这个请求会被忽略。)(此时acceptor收到了一个prepare请求，其number为n，那么这个请求会被忽略。)(此时acceptor收到了一个prepare请求，其number为n，那么这个请求会被忽略。)

2. We also have it ignore a prepare request for a proposal it has already accepted.

(同理，如果这个prepare请求的proposal已经被accept，那么也会被忽略。)(同理，如果这个prepare请求的proposal已经被accept，那么也会被忽略。)(同理，如果这个prepare请求的proposal已经被accept，那么也会被忽略。)

Putting the actions of the proposer and acceptor together, we see that the algorithm operates at the beginning two phases.
(有了proposer和acceptor的行动方式，回到开头的二阶段算法。)(有了proposer和acceptor的行动方式，回到开头的二阶段算法。)(有了proposer和acceptor的行动方式，回到开头的二阶段算法。)

\space

Learning a Chosen Value 学习已选值（用于获得状态机命令序列）

\space
To learn that a value has been chosen, a learner must find out that a proposal has been accepted by a majority of acceptors,there are two algorithm:
(为了让learner学到已被选的value。learner必须发现多数acceptor已accept的proposal，有以下两种算法：)(为了让learner学到已被选的value。learner必须发现多数acceptor已accept的proposal，有以下两种算法：)(为了让learner学到已被选的value。learner必须发现多数acceptor已accept的proposal，有以下两种算法：)

1. The obvious algorithm is to have each acceptor, whenever it accepts a proposal, respond to all learners, sending them the proposal. This allows learners to find out about a chosen value as soon as possible, but it requires each acceptor to respond to each learner.

(每个acceptor在accept时，通知所有learner其proposal。问题在于response的数量为acceptor与learner乘积。)(每个acceptor在accept时，通知所有learner其proposal。问题在于response的数量为acceptor与learner乘积。)(每个acceptor在accept时，通知所有learner其proposal。问题在于response的数量为acceptor与learner乘积。)

2. We can have the acceptors respond with their acceptances to a distinguished learner, which in turn informs the other learners when a value has been chosen. This approach requires an extra round for all the learners to discover the chosen value. It is also less reliable, since the distinguished learner could fail. But it requires a number of responses equal only to the sum of the number of acceptors and the number of learners.

(选一个杰出learner，acceptors先将proposal在accept时发给这个learner。杰出learner在value选出时将value)(选一个杰出learner，acceptors先将proposal在accept时发给这个learner。杰出learner在value选出时将value)(选一个杰出learner，acceptors先将proposal在accept时发给这个learner。杰出learner在value选出时将value)
(发给其他learner。好处在于response的数量为acceptor+learner。)(发给其他learner。好处在于response的数量为acceptor+learner。)(发给其他learner。好处在于response的数量为acceptor+learner。)
(问题在于多一轮的value通知以及单点问题。)(问题在于多一轮的value通知以及单点问题。)(问题在于多一轮的value通知以及单点问题。)

3. More generally, the acceptors could respond with their acceptances to some set of distinguished learners, each of which can then inform all the learners when a value has been chosen.

(算法二的改版：将一个杰出learner，改为多个learner集。)(算法二的改版：将一个杰出learner，改为多个learner集。)(算法二的改版：将一个杰出learner，改为多个learner集。)

Because of message loss, a value could be chosen with no learner ever finding out. The learner could ask the acceptors what proposals they have accepted, but failure of an acceptor could make it impossible to know whether or not a majority had accepted a particular proposal. In that case, learners will find out what value is chosen only when a new proposal is chosen. If a learner needs to know whether a value has been chosen, it can have a proposer issue a proposal, using the algorithm described above.

(由于message可能丢失，一个值可能在没有learner学得的情况下被choose。learner可以询问acceptor已经接受)(由于message可能丢失，一个值可能在没有learner学得的情况下被choose。learner可以询问acceptor已经接受)(由于message可能丢失，一个值可能在没有learner学得的情况下被choose。learner可以询问acceptor已经接受)
(的proposal。但当acceptor发生错误时，其保存信息未必有这次记录。此时若learner想知道某value是否被choose)(的proposal。但当acceptor发生错误时，其保存信息未必有这次记录。此时若learner想知道某value是否被choose)(的proposal。但当acceptor发生错误时，其保存信息未必有这次记录。此时若learner想知道某value是否被choose)
(过，可以让proposer再issue一个proposal看看value是否相同。)(过，可以让proposer再issue一个proposal看看value是否相同。)(过，可以让proposer再issue一个proposal看看value是否相同。)

\space

Proposer’s progress collision 二阶段中的前进冲突

collision

1. Proposer p completes phase 1 for a proposal number n1. Another proposer q then completes phase 1 for a proposal number n2 > n1.

(proposerp在phase1propose了一个number为n1的proposal；)(proposer \space p在phase \space 1 \space propose了一个number为n1的proposal；)(proposer p在phase 1 propose了一个number为n1的proposal；)
(proposerq在phase1propose了一个number为n2>n1的proposal。)(proposer \space q在phase \space 1 \space propose了一个number为n2>n1的proposal。)(proposer q在phase 1 propose了一个number为n2>n1的proposal。)

2. Proposer p’s phase 2 accept requests for a proposal numbered n1 are ignored because the acceptors have all promised not to accept any new proposal numbered less than n2.

(proposerp在phase2propose了一个number为n1的proposal被忽略；)(proposer \space p在phase \space 2 \space propose了一个number为n1的proposal被忽略；)(proposer p在phase 2 propose了一个number为n1的proposal被忽略；)
(因为acceptor已经承诺不接受任何小于n2的proposal。)(因为acceptor已经承诺不接受任何小于n2的proposal。)(因为acceptor已经承诺不接受任何小于n2的proposal。)

3. So, proposer p then begins and completes phase 1 for a new proposal number n3 > n2, causing the second phase 2 accept requests of proposer q to be ignored. And so on.

(proposerp在phase1propose了一个number为n3>n2的proposal；)(proposer \space p在phase \space 1 \space propose了一个number为n3>n2的proposal；)(proposer p在phase 1 propose了一个number为n3>n2的proposal；)
(proposerq在phase2propose了一个number为n2的proposal被忽略。)(proposer \space q在phase \space 2 \space propose了一个number为n2的proposal被忽略。)(proposer q在phase 2 propose了一个number为n2的proposal被忽略。)
(因为acceptor已经承诺不接受任何小于n3的proposal。循环往复难以前行。)(因为acceptor已经承诺不接受任何小于n3的proposal。循环往复难以前行。)(因为acceptor已经承诺不接受任何小于n3的proposal。循环往复难以前行。)

\space

solution

A distinguished proposer must be selected as the only one to try issuing proposals.
(选一个杰出的proposer用于唯一issueproposal，以下演示两种情况：)(选一个杰出的proposer用于唯一issue\space proposal，以下演示两种情况：)(选一个杰出的proposer用于唯一issue proposal，以下演示两种情况：)

1. If the distinguished proposer can communicate successfully with a majority of acceptors, and if it uses a proposal with number greater than any already used, then it will succeed in issuing a proposal that is accepted.

(杰出proposer如果用一个number大于任何已经使用的number的proposal，)(杰出proposer如果用一个number大于任何已经使用的number的proposal，)(杰出proposer如果用一个number大于任何已经使用的number的proposal，)
(那么它的proposal会被issue且最终被接受。)(那么它的proposal会被issue且最终被接受。)(那么它的proposal会被issue且最终被接受。)

2. By abandoning a proposal and trying again if it learns about some request with a higher proposal number, the distinguished proposer will eventually choose a high enough proposal number.

(如果其proposal不满足1，那么会被放弃，且重新尝试获得更高number的proposal。)(如果其proposal不满足1，那么会被放弃，且重新尝试获得更高number的proposal。)(如果其proposal不满足1，那么会被放弃，且重新尝试获得更高number的proposal。)
(这个过程知道number最大，proposal最终被接受。)(这个过程知道number最大，proposal最终被接受。)(这个过程知道number最大，proposal最终被接受。)

\space

Implemention’s essence 二阶段算法具体实行要点

1. The algorithm chooses a leader, which plays the roles of the distinguished proposer and the distinguished learner.

(选一个process作为leader，并扮演杰出proposer以及learner。)(选一个process作为leader，并扮演杰出proposer以及learner。)(选一个process作为leader，并扮演杰出proposer以及learner。)

2. Requests and responses are sent as ordinary messages.(Response messages are tagged with the corresponding proposal number to prevent confusion.)

(每个request、responce通过proposalnumber区分。)(每个request、responce通过proposal \space number区分。)(每个request、responce通过proposal number区分。)

3. Stable storage, preserved during failures, is used to maintain the information that the acceptor must remember.

(稳定的存储保证了acceptor信息。)(稳定的存储保证了acceptor信息。)(稳定的存储保证了acceptor信息。)

4. Different proposers choose their numbers from disjoint sets of numbers, so two different proposers never issue a proposal with the same number.

(为了两个Proposal的number唯一，它们number选取是不相交集。)(为了两个Proposal的number唯一，它们number选取是不相交集。)(为了两个Proposal的number唯一，它们number选取是不相交集。)

5. Each proposer remembers (in stable storage) the highest-numbered proposal it has tried to issue, and begins phase 1 with a higher proposal number than any it has already used.

(proposal会记录自己发过的最大number，保证下次发是最大。)(proposal会记录自己发过的最大number，保证下次发是最大。)(proposal会记录自己发过的最大number，保证下次发是最大。)

\space

Implementing a State Machine 共识引入状态机

\space

single server’s distributed system with state machine 单服务器、状态机分布式系统

\space

1. A simple way to implement a distributed system is as a collection of clients that issue commands to a central server.

(这个分布式系统由一群会发command的client，一个会接受command的server组成。)(这个分布式系统由一群会发command的client，一个会接受command的server组成。)(这个分布式系统由一群会发command的client，一个会接受command的server组成。)

2. The server can be described as a deterministic state machine that performs client commands in some sequence. The state machine has a current state; it performs a step by taking as input a command and producing an output and a new state.

(这个server有一个状态机，由[command,state]二元组组成。状态机把command当作输入，)(这个server有一个状态机，由[command,state]二元组组成。状态机把command当作输入，)(这个server有一个状态机，由[command,state]二元组组成。状态机把command当作输入，)
(并根据当前state通过输入转成新的state，并输出。)(并根据当前state通过输入转成新的state，并输出。)(并根据当前state通过输入转成新的state，并输出。)

3. The clients of a distributed banking system might be tellers, and the state-machine state might consist of the account balances of all users. A withdrawal would be performed by executing a state machine command that decreases an account’s balance if and only if the balance is greater than the amount withdrawn, producing as output the old and new balances.

(举一个银行系统的例子：client由user组成，state为user的balance，command为中交易operation。)(举一个银行系统的例子：client由user组成，state为user的balance，command为中交易operation。)(举一个银行系统的例子：client由user组成，state为user的balance，command为中交易operation。)
(当一个扣款operation到来，当且仅当存款足够这个状态满足，才会扣钱成新状态，并输出扣款数。)(当一个扣款operation到来，当且仅当存款足够这个状态满足，才会扣钱成新状态，并输出扣款数。)(当一个扣款operation到来，当且仅当存款足够这个状态满足，才会扣钱成新状态，并输出扣款数。)
\space

multiple server’s distributed system with state machine 多服务器、状态机分布式系统

\space

1. An implementation that uses a single central server fails if that server fails. We therefore instead use a collection of servers, each one independently implementing the state machine.

(单个server自然会产生单点问题。因此用server集代替。每个server独立运行状态机。)(单个server自然会产生单点问题。因此用server集代替。每个server独立运行状态机。)(单个server自然会产生单点问题。因此用server集代替。每个server独立运行状态机。)

2. Because the state machine is deterministic, all the servers will produce the same sequences of states and outputs if they all execute the same sequence of commands.

(由于状态机是不可逆转的。若server都根据相同的command序列来执行，其新状态与output)(由于状态机是不可逆转的。若server都根据相同的command序列来执行，其新状态与output)(由于状态机是不可逆转的。若server都根据相同的command序列来执行，其新状态与output)
(应该都是相一致的。)(应该都是相一致的。)(应该都是相一致的。)

3. A client issuing a command can then use the output generated for it by any server

(issue了一个command的client可以使用任意server的output。)(issue了一个command的client可以使用任意server的output。)(issue了一个command的client可以使用任意server的output。)

\space

Implemention consensus algorithm 将共识算法引入分布式系统

\space

1. To guarantee that all servers execute the same sequence of state machine commands, we implement a sequence of separate instances of the Paxos consensus algorithm, the value chosen by the i th instance being the i th state machine command in the sequence.

(为了保证每个server都执行相同的command序列。将共识算法的独立实例序列引入分布式系统。)(为了保证每个server都执行相同的command序列。将共识算法的独立实例序列引入分布式系统。)(为了保证每个server都执行相同的command序列。将共识算法的独立实例序列引入分布式系统。)
(第i个instance被选的value，对应了状态机即将执行command序列中的第i个command。)(第i个instance被选的value，对应了状态机即将执行command序列中的第i个command。)(第i个instance被选的value，对应了状态机即将执行command序列中的第i个command。)

2. Each server plays all the roles (proposer, acceptor, and learner) in each instance of the algorithm，and a single server is elected to be the leader, which acts as the distinguished proposer.

(每个server扮演所有的角色。其中一个server被选为leader，作为issueproposer的杰出proposer。)(每个server扮演所有的角色。其中一个server被选为leader，作为issue\space proposer的杰出proposer。)(每个server扮演所有的角色。其中一个server被选为leader，作为issue proposer的杰出proposer。)

3. Clients send commands to the leader.If the leader decides that a certain client command should be the 135th command, it tries to have that command chosen as the value of the 135th instance of the consensus algorithm.

(client发送command给leader。如果leader决定这个command是第135个，那么他会令这个command)(client发送command给leader。如果leader决定这个command是第135个，那么他会令这个command)(client发送command给leader。如果leader决定这个command是第135个，那么他会令这个command)
(作为第135个实例的value通过共识算法被选择。)(作为第135个实例的value通过共识算法被选择。)(作为第135个实例的value通过共识算法被选择。)
\space

\space

Commnad sequence’s gap and noop command 命令序列的裂口以及noop命令

\space

Assumption.

1. The new leader, being a learner in all instances of the consensus algorithm, should know most of the commands that have already been chosen. Suppose it knows commands 1–134, 138, and 139—that is, the values chosen in instances 1–134, 138, and 139 of the consensus algorithm.

(新leader应该知道所有已经被choose的命令。假设command1−134,138,139已经被chooose。)(新leader应该知道所有已经被choose的命令。假设command1-134,138,139已经被chooose。)(新leader应该知道所有已经被choose的命令。假设command1−134,138,139已经被chooose。)
(产生这种commandgap的原因之后会讲。)(产生这种command\space gap的原因之后会讲。)(产生这种command gap的原因之后会讲。)

2. It then executes phase 1 of instances 135–137 and of all instances greater than 139. (I describe below how this is done.) Suppose that the outcome of these executions determine the value to be proposed in instances 135 and 140 .The leader then executes phase 2 for instances 135 and 140, thereby choosing commands 135 and 140.

(随后leader执行了instance135−137，以及大于>139的phase1。可以执行的原因之后会将。)(随后leader执行了instance135-137，以及大于>139的phase \space 1。可以执行的原因之后会将。)(随后leader执行了instance135−137，以及大于>139的phase 1。可以执行的原因之后会将。)
(proposal决定用135及140instance的值，因此在phase2中，最终选中了135及140command。)(proposal决定用135及140instance的值，因此在phase\space 2中，最终选中了135及140command。)(proposal决定用135及140instance的值，因此在phase 2中，最终选中了135及140command。)

\space

Question.

However, it can’t execute commands 138–140, which it also knows, because commands 136 and 137 have yet to be chosen.
(但是状态机是不可逆转的，command136及137还未被choose，command138−140无法执行。)(但是状态机是不可逆转的，command136及137还未被choose，command138-140无法执行。)(但是状态机是不可逆转的，command136及137还未被choose，command138−140无法执行。)

\space

Solution.

1. The leader could take the next two commands requested by clients to be commands 136 and 137.

(leader可以让接下来执行的两个命令为comannd136及137。)(leader可以让接下来执行的两个命令为comannd136及137。)(leader可以让接下来执行的两个命令为comannd136及137。)

2. We let it fill the gap immediately by proposing, as commands 136 and 137, a special “noop” command that leaves the state unchanged. (It does this by executing phase 2 of instances 136 and 137 of the consensus algorithm.)

(我们可以立即补上这个gap通过propose一个noopcommand，使得状态机不用改变状态。)(我们可以立即补上这个gap通过propose一个noop \space command，使得状态机不用改变状态。)(我们可以立即补上这个gap通过propose一个noop command，使得状态机不用改变状态。)
(即让instance136、137重新执行phase2。)(即让instance 136、137重新执行phase\space 2。)(即让instance136、137重新执行phase 2。)

\space

Source of the Gap 命令序列裂口的来源

\space

Assumption.

1. The leader can propose command 142 before it learns that its proposed command 141 has been chosen.

(leader在command141的phase1之后，phase2最终choose之前，可以proposecommand142。)(leader在command141的phase \space 1之后，phase\space 2最终choose之前，可以propose\space command142。)(leader在command141的phase 1之后，phase 2最终choose之前，可以propose command142。)
(即可以先开始command142的phase1。)(即可以先开始command142的phase\space 1。)(即可以先开始command142的phase 1。)

2. It’s possible for all the messages it sent in proposing command 141 to be lost, and for command 142 to be chosen before any other server has learned what the leader proposed as command 141.

(因此在可能在command141被选中之前，command142已经被选中，那么command141的phase2)(因此在可能在command141被选中之前，command142已经被选中，那么command141的phase\space 2)(因此在可能在command141被选中之前，command142已经被选中，那么command141的phase 2)
(不会发生。这会产生两种情况：)(不会发生。这会产生两种情况：)(不会发生。这会产生两种情况：)

\space

Case.

1. When the leader fails to receive the expected response to its phase 2 messages in instance 141, it will retransmit those messages.

(如果leader没有接受到command141的phase2信息，那么会重新发送command141的信息。)(如果leader没有接受到command141的phase\space 2信息，那么会重新发送command141的信息。)(如果leader没有接受到command141的phase 2信息，那么会重新发送command141的信息。)
(如果顺利的话，command141最终还是会被choose。)(如果顺利的话，command141最终还是会被choose。)(如果顺利的话，command141最终还是会被choose。)

2. However, it could fail first, leaving a gap in the sequence of chosen commands.

(但是如果command142已经被choose了，那么就产生了command序列的gap。)(但是如果command 142已经被choose了，那么就产生了command序列的gap。)(但是如果command142已经被choose了，那么就产生了command序列的gap。)

\space

Solution.

1. A newly chosen leader executes phase 1 for infinitely many instances of the consensus algorithm—in the scenario above, for instances 135–137 and all instances greater than 139.

(新的leader启动，会让无限多的问题实例重新执行一遍phase1，如上述例子中135−137及)(新的leader启动，会让无限多的问题实例重新执行一遍phase\space 1，如上述例子中135-137及)(新的leader启动，会让无限多的问题实例重新执行一遍phase 1，如上述例子中135−137及)
(>139的实例。以下是实现过程：)(>139的实例。以下是实现过程：)(>139的实例。以下是实现过程：)

2. Using the same proposal number for all instances.， it can do this by sending a single reasonably short message to the other servers.In phase 1, an acceptor responds with more than a simple OK only if it has already received a phase 2 message from some proposer.

(令问题instance的proposalnumber全部相同，是通过向其它server发短消息实现的。在phase1，)(令问题instance的proposal\space number全部相同，是通过向其它server发短消息实现的。在phase\space 1，)(令问题instance的proposal number全部相同，是通过向其它server发短消息实现的。在phase 1，)
(acceptor会对所有instance发简单的OK。但是只有回复了phase2信息的instance会发额外消息。)(acceptor会对所有instance发简单的OK。但是只有回复了phase2信息的instance会发额外消息。)(acceptor会对所有instance发简单的OK。但是只有回复了phase2信息的instance会发额外消息。)
(除了收到额外消息的instance，其它均重新经历一遍开头所提的phase1。)(除了收到额外消息的instance，其它均重新经历一遍开头所提的phase1。)(除了收到额外消息的instance，其它均重新经历一遍开头所提的phase1。)

Reading Ingestion —— Paxos Made Simple相关推荐

Paxos Made Simple 中文翻译
目录 1. 引言 2. 共识算法 2.1 问题 2.2 选择一个 value 2.3 获知选定的 value 2.4 可进行性 2.5 实现 3. 实现状态机 Paxos Made Simple 基础 ...
Paxos Made Simple
Paxos一致性算法--分布式系统中的经典算法,论文本身也有一段有趣的故事.一致性问题是分布式系统的根本问题之一,在论文中,作者一步步的加强最初一致性问题(2.1节提出的问题)的约束条件,最终导出了一 ...
Paxos Made Simple【中文翻译注解】
paxos made simple [ 翻译自 Leslie Lamport 论文 http://lamport.azurewebsites.net/pubs/paxos-simple.pdf , ...
共识算法论文——Paxos Made Simple
基础概念业界一般将 Lamport 论文里最初提出的分布式算法称之为 Basic Paxos,这是 Paxos 最基础的算法思想.Basic Paxos 算法的最终目标是通过严谨和可靠的流程来使得集 ...
Reading Ingestion —— Bigtable: A Distributed Storage System for Structured Data
Bigtable: A Distributed Storage System for Structured Data \space Acquirement 收获 Bigtable's Data Mod ...
Paxos Made Simple（译）
The Paxos algorithm, when presented in plain English, is very simple. 我叫Leslie Lamport,我最屌. 1. 简介用于 ...
分布式理论(3)：Paxos Made Simple
作者:LESLIE LAMPORT 2001 译者:phylips@bmy 2011-4-30 出处:http://duanple.blog.163.com/blog/static/709717672 ...
Paxos - 分布式表决算法
原文链接:http://en.wikipedia.org/wiki/Paxos_(computer_science) Paxos (computer science) From Wikipedia, ...
超详细解析 | 一致性协议算法-2PC、3PC、Paxos、Raft、ZAB、NWR
点击上方蓝色"方志朋",选择"设为星标" 回复"666"获取独家整理的学习资料! 来源:r6d.cn/VMW9 背景在常见的分布式系统中, ...
Paxos、Raft不是一致性算法/协议？
点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试文章作为互联网中的一员,我们时常沉浸在"分布式"的 ...