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所期望的事情么？
