使用GO实现Paxos共识算法的方法_Linux

什么是paxos共识算法

最初的服务往往都是通过单体架构对外提供的，即单server-单database模式。随着业务的不断扩展，用户和请求数都在不断上升，如何应对大量的请求就成了每个服务都需要解决的问题，这也就是我们常说的高并发。为了解决单台服务器面对高并发的苍白无力，可以通过增加服务器数量来解决，即多server-单database（master-slave）模式，此时的压力就来到了数据库一方，数据库的io效率决定了整个服务的效率，继续增加server数量将无法提升服务性能。这就衍生出了当前火热的微服务架构。当用户请求经由负载均衡分配到某一服务实例上后，如何保证该服务的其他实例最终能够得到相同的数据变化呢？这就要用到paxos分布式共识协议，paxos解决的就是共识问题，也就是一段时间后，无论get哪一个服务实例，都能获取到相同的数据。目前国内外的分布式产品很多都使用了paxos协议，可以说paxos几乎就是共识协议的标准和代名词。

paxos有两种协议，我们常常提到的其实是basic paxos，另一种叫multi paxos，如无特殊说明，本文中提到的paxos协议均为basic paxos。

paxos协议是由图灵奖获得者leslie lamport于1998年在其论文《the part-time parliament》中首次提出的，讲述了一个希腊小岛paxos是如何通过决议的。但由于该论文晦涩艰深，当时的计算机界大牛们也没几个人能理解。于是lamport2001年再次发表了《paxos made simple》，摘要部分是这么写的：

the paxos algorithm, when presented in plain english, is very simple.

翻译过来就是：不会吧，不会吧，这么简单的paxos算法不会真的有人弄不懂吧？然而事实却是很多人对paxos都望而却步，理解paxos其实并不难，但是paxos的难点在于工程化，如何利用paxos协议写出一个能过够真正在生产环境中跑起来的服务才是paxos最难的地方，关于paxos的工程化可以参考微信后台团队撰写的《微信自研生产级paxos类库phxpaxos实现原理介绍》

paxos如何保证一致性的

paxos协议一共有两个阶段：prepare和propose，两种角色：proposer和acceptor，每一个服务实例既是proposer，同时也是acceptor，proposer负责提议，acceptor决定是否接收来自proposer的提议，一旦提议被多数接受，那么我们就可以宣称对该提议包含的值达成了一致，而且不会再改变。

阶段一：prepare 准备

proposer生成全局唯一proposalid（时间戳+serverid）
proposer向所有acceptor（包括proposer自己）发送prepare(n = proposalid)请求
acceptor比较n和minproposal, if n > minproposal, minproposal = n，acceptor返回已接受的提议(acceptedproposal, acceptedvalue)
承诺1：不再接受n <= minproposal的prepare请求
承诺2：不再接受n < minproposal的propose请求
应答1：返回此前已接受的提议
当proposer收到大于半数的返回后
prepare请求被拒绝，重新生成proposalid并发送prepare请求
prepare请求被接受且有已接受的提议，选择最大的proposalid对应的值作为提议的值
prepare请求被接受且没有已接受的提议，可选择任意提议值
阶段二：propose 提议
proposer向所有acceptor（包括proposer自己）发送accept(n=proposalid,value=proposalvalue)请求
acceptor比较n和minproposal, if n >= minproposal, minproposal = n, acceptedvalue = value，返回已接受的提议（minproposal，acceptedvalue）
当proposer收到大于半数的返回后
propose请求被拒绝，重新生成proposalid并发送prepare请求
propose请求被接受，则数据达成一致性

一旦提议被半数以上的服务接受，那么我们就可以宣称整个服务集群在这一提议上达成了一致。

需要注意的是，在一个服务集群中以上两个阶段是很有可能同时发生的。例如：实例a已完成prepare阶段，并发送了propose请求。同时实例b开始了prepare阶段，并生成了更大的proposalid发送prepare请求，可能导致实例a的propose请求被拒绝。每个服务实例也是同时在扮演proposer和acceptor角色，向其他服务发送请求的同时，可能也在处理别的服务发来的请求。

使用go语言实现paxos协议

服务注册与发现

由于每个服务实例都是在执行相同的代码，那我们要如何知晓其他服务实例的入口呢（ip和端口号）？方法之一就是写死在代码中，或者提供一份配置文件。服务启动后可以读取该配置文件。但是这种方法不利于维护，一旦我们需要移除或添加服务则需要在每个机器上重新休息配置文件。

除此之外，我们可以通过一个第三方服务：服务的注册与发现来注册并获知当前集群的总服务实例数，即将本地的配置文件改为线上的配置服务。

服务注册：register函数，服务实例启动后通过调用这个rpc方法将自己注册在服务管理中

func (s *service) register(args *registerargs, reply *registerreply) error {
 s.mu.lock()
 defer s.mu.unlock()
 
 server := args.serverinfo
 for _, server := range s.servers {
  if server.ipaddress == args.serverinfo.ipaddress && server.port == args.serverinfo.port {
   reply.succeed = false
   return nil
  }
 }
 reply.serverid = len(s.servers)
 reply.succeed = true
 s.servers = append(s.servers, server)
 
 fmt.printf("current registerd servers:\n%v\n", s.servers)
 
 return nil
}

服务发现：getservers函数，服务通过调用该rpc方法获取所有服务实例的信息（ip和端口号）

func (s *service) getservers(args *getserversargs, reply *getserversreply) error {
 // return all servers
 reply.serverinfos = s.servers
 
 return nil
}

prepare阶段

proposer，向所有的服务发送prepare请求，并等待直到半数以上的服务返回结果，这里也可以等待所有服务返回后再处理，但是paxos协议可以容忍小于半数的服务宕机，因此我们只等待大于n/2个返回即可。当返回的结果有任何一个请求被拒绝，那proposer即认为这次的请求被拒绝，返回重新生成proposalid并发送新一轮的prepare请求。

func (s *server) callprepare(allservers []serverinfo, proposal proposal) preparereply {
 returnedreplies := make([]preparereply, 0)
 for _, others := range allservers {
  // use a go routine to call every server
  go func(others serverinfo) {
   delay := rand.intn(10)
   time.sleep(time.second * time.duration(delay))
   args := prepareargs{s.info, proposal.id}
   reply := preparereply{}
   fmt.printf("【prepare】call prepare on %v:%v with proposal id %v\n", others.ipaddress, others.port, args.proposalid)
   if call(others, "server.prepare", &args, &reply) {
    if reply.hasacceptedproposal {
     fmt.printf("【prepare】%v:%v returns accepted proposal: %v\n", others.ipaddress, others.port, reply.acceptedproposal)
    } else {
     fmt.printf("【prepare】%v:%v returns empty proposal\n", others.ipaddress, others.port)
    }
    s.mu.lock()
    returnedreplies = append(returnedreplies, reply)
    s.mu.unlock()
   }
  }(others)
 }
 for {
  // wait for responses from majority
  if len(returnedreplies) > (len(allservers))/2.0 {
   checkreplies := returnedreplies
   // three possible response
   // 1. deny the prepare, and return an empty/accepted proposal
   // as the proposal id is not higher than minproposalid on server (proposal id <= server.minproposalid)
   // 2. accept the prepare, and return an empty proposal as the server has not accept any proposal yet
   // 3. accept the prepare, and return an accepted proposal
   // check responses from majority
   // find the response with max proposal id
   acceptedproposal := newproposal()
   for _, r := range checkreplies {
    // if any response refused the prepare, this server should resend prepare
    if !r.prepareaccepted {
     return r
    }
    if r.hasacceptedproposal && r.acceptedproposal.id > acceptedproposal.id {
     acceptedproposal = r.acceptedproposal
    }
   }
   // if some other server has accepted proposal, return that proposal with max proposal id
   // if no other server has accepted proposal, return an empty proposal
   return preparereply{hasacceptedproposal: !acceptedproposal.isempty(), acceptedproposal: acceptedproposal, prepareaccepted: true}
  }
  //fmt.printf("waiting for response from majority...\n")
  time.sleep(time.second * 1)
 }
}

acceptor，通过比较proposalid和minproposal，如果proposalid小于等于minproposal，则拒绝该prepare请求，否则更新minproposal为proposalid。最后返回已接受的提议

func (s *server) prepare(args *prepareargs, reply *preparereply) error {
 s.mu.lock()
 defer s.mu.unlock()
 // 2 promises and 1 response
 // promise 1
 // do not accept prepare request which proposalid <= minproposalid
 // promise 2
 // do not accept propose request which proposalid < minproposalid
 // response 1
 // respond with accepted proposal if any
 if reply.prepareaccepted = args.proposalid > s.minproposalid; reply.prepareaccepted {
  // ready to accept the proposal with id s.minproposalid
  s.minproposalid = args.proposalid
 }
 reply.hasacceptedproposal = s.readacceptedproposal()
 reply.acceptedproposal = s.proposal
 return nil
}

propose阶段

proposer，同样首先向所有的服务发送propose请求，并等待知道半数以上的服务返回结果。如果返回的结果有任何一个请求被拒绝，则proposer认为这次的请求被拒绝，返回重新生成proposalid并发送新一轮的prepare请求

func (s *server) callpropose(allservers []serverinfo, proposal proposal) proposereply {
 returnedreplies := make([]proposereply, 0)
 for _, others := range allservers {
  go func(others serverinfo) {
   delay := rand.intn(5000)
   time.sleep(time.millisecond * time.duration(delay))
   args := proposeargs{others, proposal}
   reply := proposereply{}
   fmt.printf("【propose】call propose on %v:%v with proposal: %v\n", others.ipaddress, others.port, args.proposal)
   if call(others, "server.propose", &args, &reply) {
    fmt.printf("【propose】%v:%v returns: %v\n", others.ipaddress, others.port, reply)
    s.mu.lock()
    returnedreplies = append(returnedreplies, reply)
    s.mu.unlock()
   }
  }(others)
 }
 for {
  // wait for responses from majority
  if len(returnedreplies) > (len(allservers))/2.0 {
   checkreplies := returnedreplies
   for _, r := range checkreplies {
    if !r.proposeaccepted {
     return r
    }
   }
   return checkreplies[0]
  }
  time.sleep(time.second * 1)
 }
}

acceptor，通过比较proposalid和minproposal，如果proposalid小于minproposal，则拒绝该propose请求，否则更新minproposal为proposalid，并将提议持久化到本地磁盘中。

func (s *server) propose(args *proposeargs, reply *proposereply) error {
 if s.minproposalid <= args.proposal.id {
  s.mu.lock()
  s.minproposalid = args.proposal.id
  s.proposal = args.proposal
  s.saveacceptedproposal()
  s.mu.unlock()
 
  reply.proposeaccepted = true
 }
 
 reply.proposalid = s.minproposalid
 
 return nil
}

运行

运行结果：

这里我一共开启了3个服务实例，并在每次请求之前加入了随机的延迟，模拟网络通信中的延迟，因此每个服务的每个请求并不是同时发出的

动图一张：