控制结构(3): 状态机（state machine）

// 上一篇：卫语句（guard clause）

// 下一篇：局部化（localization）

---

基于语言提供的基本控制结构，更好地组织和表达程序，需要良好的控制结构。

前情回顾

上次分析了guard 控制结构，有人说：“可是阅读很多开源代码也是if/else层层嵌套的”。是的，guard控制结构只是一种风格，语言并没有规定你一定要这么写，也没必要。两种风格都能写出逻辑清晰的代码，但是还是有细微差别，嵌套模式下，要写出清晰的代码需要更好的做好函数的分层（见第1节），例如，在分支里只做函数的转发调用，那么，代码也是清晰可读的。

function doSomething(){
	if(condition1){
		call1();
	}else{
		if(condition2){
			call2();
		}else{
			call3();
		}
	}
}

我们来看一个新的结构。

典型代码：

let opening = false;
let opened = false;
let closing = false;
let closed = false;
let step1 = false;

function open(onComplete){
	if(closing||closed){
		return onComplete(RESULT.CLOSED)
	}

	if(opening){
		return onComplete(RESULT.PENDING);
	}

	if(opened){
		return onComplete(RESULT.SUCCESS);
	}

	opening = true;
	doOpen(function(err){
		onComplete(err);
		opening = false;
		opened = true;
	});
}

function close(onComplete){
	if(!opened){
		return onComplete(RESULT.INVALID_OP);
	}

	if(closing||closed){
		return onComplete(RESULT.PENDING);
	}

	closing = true;
	doClose(function(err){
		onComplete(err);
		closing = false;
		closed = true;
	})
}

function start(onComplete){
	open((err)=>{
		if(err){
			return onComplete(err);
		}
		step1((err)=>{
			if(err){
				return onComplete(err);
			}
			step2((err)=>{
				onComplete(err);
				close((err)=>{
					log(`close, ret:${err}`);
				})
			})
		})
	})
}

function step1(onComplete){
	if(!opened){
		return onComplete(RESULT.NOT_OPEN);
	}

	doStep1(function(err){
		step1 = true;
		onComplete(err);
	});
}

function step2(onComplete){
	if(!opened){
		return onComplete(RESULT.NOT_OPEN);
	}

	if(!step1){
		return onComplete(RESULT.INVALID_STEP);
	}

	doStep2(function(err){
		onComplete(err);
	});
}

结构分析

这段代码使用了多个bool变量来做状态标记，为了安全有序的做好每个异步动作，需要在适当的地方对每个bool标志变量做判断。如果这个流程继续复杂起来，bool变量之间的状态组合会变的更加繁杂，也很容易一不小心就漏掉状态的组合判断，导致难以定位的BUG。此时，我们可以采用一种重要的控制结构。

...

是的，状态机(state machine)结构。我们先来看看使用状态机控制结构改写后的代码：

/**所有的状态*/
const STATE = {
	INIT: 0,
	OPENING: 1,
	OPENED: 2,
	STEP1: 3,
	STEP2: 4,
	CLOSING: 5,
	CLOSED: 6,
	ERROR: 7
} 

/**每个状态都只允许从指定状态转移过来*/
const stateTransfer = {
	STATE.INIT: [],
	STATE.OPENING: [STATE.INIT],
	STATE.OPENED: [STATE.OPENING],
	STATE.STEP1: [STATE.OPENED],
	STATE.STEP2: [STATE.STEP1],
	STATE.CLOSING: [STATE.INIT, STATE.OPENING, STATE.OPENED, STATE.STEP1, STATE.STEP2],
	STATE.CLOSED: [STATE.CLOSING],
	STATE.ERROR: [STATE.INIT, STATE.OPENING, STATE.OPENED, STATE.STEP1, STATE.STEP2],
}

let state = STATE.INIT;
let stateChangeEvent = null;

function moveTo(err, newState){

	let nextState = err ? STATE.ERROR : newState;

	if(stateTransfer[nextState].indexOf(state)===-1){
		return RESULT.INVALID_STATE_TRANSFER;
	}

	let oldState = state;
	state = nextState;
	stateChangeEvent(oldState, state, err);

	do();

	return RESULT.SUCCESS;
}

function do(){
	switch(state){
		case STATE.INIT:
			moveTo(0, STATE.OPENING);
			break;
		case STATE.OPENING:
			doOpen((err)=>{
				moveTo(err, STATE.OPENED);
			});
			break;
		case STATE.OPENED:
			doStep1((err)=>{
				moveTo(err, STATE.STEP1);
			});
			break;
		case STATE.STEP1:
			doStep2((err)=>{
				moveTo(err, STATE.STEP2);
			});
			break;
		case STATE.STEP2:
			moveTo(0, STATE.CLOSING);
			break;
		case STATE.CLOSING:
			doClose((err)=>{
				moveTo(err, STATE.CLOSED);
			});
			break;
		case STATE.CLOSED:
			break;
		default:
			break;
	}
}

function start(onStateChange){
	stateChangeEvent = onStateChange;
	do();
}

语义分析

看上去好像多了很多代码。然而在复杂的异步处理流程中，状态机能清晰地表达逻辑，保证逻辑代码的时序，并在形式推理上发现和消灭漏洞，阅读do里面的逻辑，状态之间的转换直接、明显。编程语言提供了基本的状态标志位：bool变量。这便于让程序员在编程中随意地使用bool变量标记各种状态，但0/1状态标示在稍微复杂一点的状态变化中，就会显得不好用：

• 出现组合爆炸，你需要对多个bool变量做组合判断，这很容易漏掉某个状态组合。
• 设计上的失误，导致bool标志位之间不是正交的，因而任一时刻，程序的状态不能确保唯一，这会导致程序出现未知的时序问题。

事实上，任何程序在运行中本身就是一个状态机：

• 当前在第i行执行
• 根据条件，进入第j行执行

这里的状态就是：

• pc, 也就是program counter, 程序计数器
• condition，改变pc的条件

如果想更清楚地理解这点，可以观看Lamport制作的视频，要看到第2集：

http://lamport.azurewebsites.net/video/intro.html