paxos算法java代码实现

paxos算法以其难以理解而著称，主要体现在两个方面：

1、Lamport最初的论文以叙事的方式叙述了算法核心

2、算法即使有非常严谨的推导过程也很难被确定为严格正确的（但目前事实证明确实是有效的）

目前在网络上很多类似的推导过程，自己看着也很困惑，所以尝试使用代码实现了这个过程，记录如下：

importjava.util.ArrayList;

importjava.util.List;

importjava.util.Random;

/**

* Phase 1

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

* (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 pro-posal (if any) that it has accepted.

* Phase 2

* (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.

* (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.

*/

public classPaxos {

public static voidmain(String[] args) {

ComputerManager computerManager =newPaxos().newComputerManager();

try{

computerManager.start(7);

}catch(Exception e) {

e.printStackTrace();

}

}

classComputerManager {

privateListcomputers=newArrayList();//定义一个集合

privateIntegerstartSize;

/**

*启动所有服务器

*

*@throwsException

*/

public voidstart(Integer startSize)throwsException {

if(computers!=null&&computers.size() >0)

throw newException("restart error");

this.startSize= startSize;

Paxos paxos =newPaxos();

for(inti =0;i < startSize;i++) {

Computer computer = paxos.newComputer(this);

Thread thread =newThread(computer);

thread.start();

}

}

/**

*启动完成的服务器注册

*

*@return

*/

public voidregister(Computer computer) {

computers.add(computer);

}

/**

*获取所有服务器

*

*@return

*/

publicIntegergetHelfSize() {

returncomputers.size() /2+1;

//            return startSize / 2 + 1;

}

/**

*获取一个法定集合

*

*@return

*/

public synchronizedListgetLegalComputers() {

List list =newArrayList();

intcount =0;

intcomputerSize =computers.size();

inthelfCount = computerSize /2+1;

Random random =newRandom();

while(count < helfCount) {

//生成一个随机数

int_random = Math.abs(random.nextInt(computerSize));

if(_random >=0&& _random < computerSize) {

Computer _computer =computers.get(_random);

if(!list.contains(_computer)) {

list.add(_computer);

count++;

}

}

}

returnlist;

}

}

classComputerimplementsRunnable {

privateIntegerid= Math.abs(newRandom().nextInt());//服务器ID

privateIntegermaxN;//当前接收到的提案号

privateIntegeracceptN;//已经同意的提案号

privateIntegeracceptV;//已经同意的提案号对应的值

privateComputerManagercomputerManager;

Computer(ComputerManager computerManager) {

this.computerManager= computerManager;

}

public synchronizedObject[]prepaer(Integer acceptN) {

System.out.println("---------------------------------------------------分割线------------------------------");

System.out.println(acceptN +"申请提案:"+this.id+".........."+this.maxN+"........"+this.acceptN+"......"+this.acceptV);

/*这里模拟一个断网情况，如果随机为2则断网*/

Random random =newRandom();

intstate = random.nextInt(10);

if(state ==2)

return null;

/*以下为正常情况*/

//如果之前没有接受过提案，直接返回null

if(maxN==null) {

this.maxN= acceptN;//令当前接收到的提案号=当前申请的提案号

return newObject[]{"pok", null, null};

}

if(maxN> acceptN) {

//由于当前申请提案号小于已经同意的提案号，所以不接收提案申请

return newObject[]{"error", null, null};

}

if(acceptN >maxN) {//判断新申请的提案是否为新提案

this.maxN= acceptN;//令当前接收到的提案号=当前申请的提案号

if(this.acceptN==null) {//如果之前没有通过任何提案，返回null

return newObject[]{"pok", null, null};

}else{

//如果之前同意过提案，返回最后同意的提案编号和提案值

return newObject[]{"pok", this.acceptN, this.acceptV};

}

}

return null;

}

public synchronizedStringaccept(Integer acceptN,Integer acceptV) {

//首先当前申请的提案号acceptN不能小于maxN

if(maxN<= acceptN) {

maxN= acceptN;

this.acceptN= acceptN;

this.acceptV= acceptV;

return"aok";

}

return"error";

}

/**

*进行选举

*/

public voidpaxos(Computer computer) {

//获取一个法定集合

List computers =computerManager.getLegalComputers();

Integer _acceptN =0;

Integer _acceptV =0;

intcount =0;

Integer cid = CId.getCid();

for(Computer _computer : computers) {

Object[] prepaer = _computer.prepaer(cid);//申请提交提案

if(prepaer ==null)

continue;

System.out.println(cid +"("+ _acceptN +":"+ _acceptV +")"+"返回提案:"+ _computer.id+".........."+ prepaer[0] +"........"+ prepaer[1] +"......"+ prepaer[2]);

String state = (String) prepaer[0];

if("pok".equals(state))//接收到申请的情况

{

count++;

if(_acceptN ==0&& prepaer[1] ==null) {

//生成一个新的acceptV

_acceptV = computer.id;

}else{

Integer acceptN = (Integer) prepaer[1];

Integer acceptV = (Integer) prepaer[2];

//使用返回的acceptV

if(acceptN >= _acceptN) {

_acceptN = acceptN;

_acceptV = acceptV;

}

}

}

}

//如果接收到的回复超过了半数，则正式提交提案

if(count >=computerManager.getHelfSize()) {

_acceptN = cid;

//获取一个法定集合

List computers1 =computerManager.getLegalComputers();

intacount =0;

for(Computer _computer : computers1) {

System.out.println(_acceptN +"("+ _acceptV +")"+"提交提案:"+ _computer.id+".........."+ _computer.maxN+"........"+ _computer.acceptN+"......"+ _computer.acceptV);

String accept = _computer.accept(_acceptN,_acceptV);//申请提交提案

if("aok".equals(accept)) {

acount++;

}

}

if(acount >=computerManager.getHelfSize()) {

System.out.println("提案被多数通过:"+ _acceptN +"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"+ _acceptV);

for(Computer _computer : computers1) {

System.out.println(_computer.id+".........."+ _computer.maxN+"........"+ _computer.acceptN+"......"+ _computer.acceptV);

}

}

}

}

/**

*启动命令

*/

public voidrun() {

//            Random random = new Random();

//            try {

//                Thread.sleep(random.nextInt(10) * 1000);//随机延迟几秒，模拟消息发送过程或启动过程

//            } catch (InterruptedException e) {

//                e.printStackTrace();

//            }

Computer computer =this;

computerManager.register(computer);//注册到启动集群中

paxos(computer);

}

}

/**

*提案号管理类d

*/

static classCId {

privateIntegercid=1;

privateCId() {

}

private staticCIdinstance=newCId();

public synchronized staticIntegergetCid() {

returninstance.cid++;

}

}

}

程序在运行过程中会出现异常，但是也能选出合适的人选作为Leader，这不正是paxos所期望的事情么？