工作中应用到了状态机，学习过程中发现，如果状态机使用得当，那么就会事半功倍。中间也陆陆续续学习研究了状态机的相关知识。所以，在这里做个总结，同时也分享出来。
本文首先简单介绍状态机的基本知识（建议找专门专业的介绍状态机的书籍进行学习），然后基于十字转门的例子，以迁移表的方式来实现有限状态机的功能，接着再介绍经典的状态机模式，最后重点介绍boost startchart的相关知识点，boost startchart是boost实现的状态机库，它几乎支持了所有的UML中状态机的特性，主要学习的途径就是官网提供的指南，该指南信息量很大，但是学习起来有点费劲，而且例子也不够完整，所以，本文也会基于它提供的例子，比如hello world、秒表、数码相机，重新梳理总结它的应用方式，至于高级议题，可能需要再花时间进行研究。
一、状态机基本知识
一般状态机由三个元素组成：状态、事件、反应。而反应在boost startchart包括转移、动作等。一个状态可以对应一个或者多个反应。
当前状态收到事件后，执行反应，然后转变为新的状态。该流程会使用下图的方式来表示。
状态机通常都需要有历史状态，可以用来恢复，它分为浅历史和深历史两类。
历史状态是伪状态, 其目的是记住从组合状态中退出时所处的子状态, 当再次进入组合状态时, 可以直接进入这个子状态, 而不是再从组合状态的初态开始。
浅历史状态, 只记住最外层组合状态的历史，使用大写H来表示。
深历史状态, 可以记住任意深度的组合状态的历史，使用大写H和星号组合来表示。
二、迁移表
进出地铁的时候，有时候设置的是一个十字转门，十字转门默认是锁的状态，当投入硬币之后，当前十字转门就会变成解锁状态，当人通过之后，十字转门又会变成锁的状态。当十字转门是锁的状态，但是强行通过，就会发出警告信息。其状态的转换如下图所示。
接下来，我们通过迁移表的方式来说实现上图的状态机图。
首先定义实现动作类接口和实现，即unlock/lock/alarm/thanks。这里定义十字转门的控制接口JTurnstileControlInterface，主要是依据开闭原则，当动作类的功能改变的时候，只需要继承JTurnstileControlInterface接口类，然后重新实现对应的接口函数。
/// 十字转门控制接口
class JTurnstileControlInterface
{
public:
virtual void lock() = 0;
virtual void unlock() = 0;
virtual void thanks() = 0;
virtual void alarm() = 0;
};
/// 十字转门控制类
class JTurnstileControler : public JTurnstileControlInterface
{
public:
virtual void lock() override;
virtual void unlock() override;
virtual void thanks() override;
virtual void alarm() override;
};
/// 十字转门控制类的实现
void JTurnstileControler::lock()
{
LOG(INFO) << "action lock";
}
void JTurnstileControler::unlock()
{
LOG(INFO) << "action unlock";
}
void JTurnstileControler::thanks()
{
LOG(INFO) << "action thanks";
}
void JTurnstileControler::alarm()
{
LOG(INFO) << "action alarm";
}
然后定义状态和事件，LOCKED和UNLOCKED表示的是十字转门的状态，COIN和PASS表示的是十字转门收到的事件。
// 状态
static const int LOCKED = 0;
static const int UNLOCKED = 1;
// 事件
static const int COIN = 0;
static const int PASS = 1;
有了上面的基础之后，最后就可以以迁移表的方式来实现十字转门的状态机图。
定义十字转门类，构造函数接受动作类，event接收事件，Transition是存储状态转移关系的内部类。
class Turnstile
{
public:
// 传入动作
Turnstile(JTurnstileControlInterface* pControler);
// 接受事件
void event(int event);
private:
typedef std::function<void ()> Action;
class Transition
{
public:
Transition(int curState, int event, int newState, Action action)
: m_curState(curState)
, m_event(event)
, m_newState(newState)
, m_action(action)
{}
int m_curState;
int m_event;
int m_newState;
Action m_action;
};
// 添加迁移关系到vector向量
void AddTransition(int curState, int event, int newState, Action action);
private:
JTurnstileControlInterface* m_pTurnstileConstroler;
std::vector<Transition*> m_vecTransition;
int m_iState;
};
实现十字转门类，event是处理接收到事件的函数，该函数会遍历vector向量中存储的状态迁移表，如果匹配到对应的事件，那么修改当前的状态，并且执行对应的动作。
Turnstile::Turnstile(JTurnstileControlInterface* pControler)
: m_iState(LOCKED)
{
m_pTurnstileConstroler = pControler;
AddTransition(LOCKED, COIN, UNLOCKED, std::bind(&JTurnstileControlInterface::unlock, m_pTurnstileConstroler));
AddTransition(LOCKED, PASS, LOCKED, std::bind(&JTurnstileControlInterface::alarm, m_pTurnstileConstroler));
AddTransition(UNLOCKED, COIN, UNLOCKED, std::bind(&JTurnstileControlInterface::thanks, m_pTurnstileConstroler));
AddTransition(UNLOCKED, PASS, LOCKED, std::bind(&JTurnstileControlInterface::lock, m_pTurnstileConstroler));
}
void Turnstile::AddTransition(int curState, int event, int newState, Action action)
{
m_vecTransition.push_back(new Transition(curState, event, newState, action));
}
void Turnstile::event(int event)
{
for(unsigned int i = 0; i < m_vecTransition.size(); i++)
{
Transition* p_trans = m_vecTransition.at(i);
if (m_iState == p_trans->m_curState && event == p_trans->m_event)
{
m_iState = p_trans->m_newState;
p_trans->m_action();
break;
}
}
}
实现完成十字转门之后，现在就来验证下效果，首先创建十字转门的动作对象指针，将其传入十字转门对象的构造函数，然后调用event函数，传入事件COIN, 执行完成之后，再传入事件PASS，来查看当前动作的执行是否正确。
JTurnstileControler* p_controler = new JTurnstileControler();
Turnstile turnstile(p_controler);
turnstile.event(COIN);
turnstile.event(PASS);
最后运行程序，输出的信息如下，从中可以看到，接收到COIN事件，执行了unlock动作，接收到PASS事件，执行了lock动作，这个符合预期。
[virtual void JTurnstileControler::unlock():36] action unlock
[virtual void JTurnstileControler::lock():31] action lock
三、状态机模式
上面通过迁移表的方式来实现状态机图，接下来就来介绍状态机模式，该设计模式也是比较经典的。它将状态逻辑与动作解耦，context是上下文对象，它主要实现动作功能，该状态机的模式的主要关键点是，状态对象持有context上下文对象的指针。
定义状态基类、状态A和状态B
class Context;
/// 状态基类
class State
{
public:
State();
virtual ~State();
virtual void OperationInterface(Context* ) = 0;
virtual void OperationChangeState(Context* ) = 0;
protected:
bool ChangeState(Context* con,State* st);
};
/// 状态对象A
class SubStateA : public State
{
public:
SubStateA();
virtual ~SubStateA();
virtual void OperationInterface(Context* );
virtual void OperationChangeState(Context*);
protected:
private:
};
/// 状态对象B
class SubStateB : public State
{
public:
SubStateB();
virtual ~SubStateB();
virtual void OperationInterface(Context* );
virtual void OperationChangeState(Context*);
protected:
private:
};
接着实现定义状态基类、状态A和状态B
///
/// State
///
State::State()
{
}
State::~State()
{
}
void State::OperationInterface(Context*)
{
}
void State::OperationChangeState(Context*)
{
}
bool State::ChangeState(Context* con,State* st)
{
con->ChangeState(st);
return true;
}
///
/// SubStateA
///
SubStateA::SubStateA()
{
}
SubStateA::~SubStateA()
{
}
void SubStateA::OperationInterface(Context* )
{
LOG(INFO) << "SubStateA::OperationInterface";
}
void SubStateA::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con,new SubStateB());
}
///
/// SubStateB
///
SubStateB::SubStateB()
{
}
SubStateB::~SubStateB()
{
}
void SubStateB::OperationInterface(Context* )
{
LOG(INFO) << "SubStateB::OperationInterface";
}
void SubStateB::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con,new SubStateA());
}
最后关键是定义上下文对象context, 其中声明State为Context的友元类，这表明在State类中可以访问 Context 类的 private 字段。
class Context
{
public:
Context();
Context(State* state);
~Context();
void OprationInterface();
void OperationChangState();
protected:
private:
friend class State; //表明在State类中可 以访问 Context 类的 private 字段
bool ChangeState(State* state);
private:
State* m_pState;
};
实现上下文对象context
///
/// Context
///
Context::Context()
{
}
Context::Context(State* state)
{
this->m_pState = state;
}
Context::~Context()
{
delete m_pState;
}
void Context::OprationInterface()
{
m_pState->OperationInterface(this);
}
bool Context::ChangeState(State* state)
{
this->m_pState = state;
return true;
}
void Context::OperationChangState()
{
m_pState->OperationChangeState(this);
}
实现完成所有状态机相关的代码之后，现在就来验证下状态的转移效果。
State* p_state_a = new SubStateA();
Context* p_context = new Context(p_state_a);
p_context->OperationChangState();
p_context->OperationChangState();
p_context->OperationChangState();
if (p_context != nullptr)
{
delete p_context;
p_context = nullptr;
}
if (p_state_a != nullptr)
{
p_state_a = nullptr;
}
运行输出的打印信息如下，状态的转移从A到B，再到A。
[virtual void SubStateA::OperationInterface(Context *):71] SubStateA::OperationInterface
[virtual void SubStateB::OperationInterface(Context *):95] SubStateB::OperationInterface
[virtual void SubStateA::OperationInterface(Context *):71] SubStateA::OperationInterface
四、boost startchart
boost startchart是boost实现的状态机库，它几乎支持了所有的UML中状态机的特性。
首先来看下一个简单的实现来初步了解其使用方法和机制。boost::statechart的状态机，它大量了引用了CRTP, 基本思想要点是：派生类要作为基类的模版参数。更详细的原理可以参考《学会了这么神奇的模版模式，让你C++模版编程之路事半功倍》。首先需要实现继承state_machine的类Machine，其初始状态为Greeting。然后再实现继承simple_state的状态Greeting。
class Greeting;
class Machine : public boost::statechart::state_machine< Machine, Greeting >
{
public:
void Print() { LOG(INFO) << "xxx"; }
};
class Greeting : public boost::statechart::simple_state< Greeting, Machine >
{
public:
Greeting() { LOG(INFO) << "Hello World!"; } // entry 進入
~Greeting() { LOG(INFO) << "Bye Bye World!"; } // exit 退出
};
然后看下如何启动和使用上面实现的”hello world”的功能。状态机Machine构建完成之后，需要调用initiate让它运行，并且进入初始状态Greeting。
Machine my_machine;
my_machine.initiate();
下面来实现稍微复杂的秒表功能，该秒表有两个按钮：开始/接收(Start/Stop) 和 重置（Reset）, 对应有两个状态Stopped和Running。其状态图如下所示。
首先定义两个事件EvStartStop和EvReset，所有事件都要继承event
class EvStartStop : public boost::statechart::event< EvStartStop > {};
class EvReset : public boost::statechart::event< EvReset > {};
然后实现继承state_machine的秒表StopWatch状态机，其初始状态为Active。
class Active;
class StopWatch : public boost::statechart::state_machine< StopWatch, Active >
{
public:
double ElapsedTime() const
{
return state_cast< const IElapsedTime & >().ElapsedTime();
}
};
接着实现Active状态，m_dElapsedTime是记录当前秒表走的时长，simple_state接受四个参数，第一个参数当然就是Active本身，第二个参数因为Active是最外层的状态，所以要设置它所属的状态机为StopWatch，第三个参数则是设置Active的初始状态为Stopped。注意“typedef boost::statechart::transition< EvReset, Active > reactions; 的格式是固定的，表示如果收到EvReset事件，那么转移到Active状态。
/// simple_state 类模版接受四个参数：
/// 第二个参数 Active是最外层的状态，因此要被传递给所属的状态机
/// 第三个参数 指定内层的初始状态
/// 第四个参数 指定是否保存历史及保存何种历史
class Stopped;
class Active : public boost::statechart::simple_state< Active, StopWatch, Stopped >
{
public:
typedef boost::statechart::transition< EvReset, Active > reactions;
Active(): m_dElapsedTime(0.0) {}
double ElapsedTime() const { return m_dElapsedTime; }
double & ElapsedTime() { return m_dElapsedTime; }
private:
double m_dElapsedTime;
};
定义IElapsedTime接口类，它由Running和Stopped两个状态来继承和实现
class IElapsedTime
{
public:
virtual double ElapsedTime() const = 0;
};
实现Stopped状态，它指定Active为它的context, 这样它就会嵌套到Active中，这里实现的ElapsedTime函数，主要用于在Stopped状态下，StopWatch可以获取当前秒表的值。
class Stopped : public boost::statechart::simple_state< Stopped, Active >, public IElapsedTime
{
public:
typedef boost::statechart::transition< EvStartStop, Running > reactions;
virtual double ElapsedTime() const
{
return context< Active >().ElapsedTime();
}
};
实现Running状态，同样的，它也指定Active为它的context, 这样它就会嵌套到Active中。注意Running状态下使用context<Active>则直接访问Running的直接外层状态Active.
class Running : public boost::statechart::simple_state< Running, Active >, public IElapsedTime
{
public:
// 一个状态可以定义任意数量的反应，所以当反应多于一个时，要将它们放入一个mpl::list<>
typedef boost::statechart::transition< EvStartStop, Stopped > reactions;
Running(): m_StartTime(0) {}
~Running()
{
// context<>() 用于访问一个状态的直接或间接上下文
// 这可以是直接或者间接外层状态或者状态机本身
context< Active >().ElapsedTime() = ElapsedTime();
}
virtual double ElapsedTime() const
{
return context< Active >().ElapsedTime() +
std::difftime( std::time( 0 ), m_StartTime );
}
private:
std::time_t m_StartTime;
};
完成秒表的所有实现之后，现在就可以编写测试代码来测试状态的转移情况。
StopWatch my_watch;
my_watch.initiate();
LOG(INFO) << "01 " << my_watch.ElapsedTime();
my_watch.process_event( EvStartStop() );
LOG(INFO) << "02 " << my_watch.ElapsedTime();
my_watch.process_event( EvStartStop() );
LOG(INFO) << "03 " << my_watch.ElapsedTime();
my_watch.process_event( EvStartStop() );
LOG(INFO) << "04 " << my_watch.ElapsedTime();
my_watch.process_event( EvReset() );
LOG(INFO) << "05 " << my_watch.ElapsedTime();
编译运行之后的打印信息如下，可以看出开始秒表的时长是0，发布EvStartStop事件之后，秒表的时长就不为0，当发布EvReset事件之后，秒表的时长再次变成0，说明重新进入了Active状态，m_dElapsedTime变量重置为0。
[void JTestBoost::TestStopwatch():302] 01 0
[void JTestBoost::TestStopwatch():304] 02 1.58486e+09
[void JTestBoost::TestStopwatch():306] 03 1.58486e+09
[void JTestBoost::TestStopwatch():308] 04 3.16971e+09
[void JTestBoost::TestStopwatch():310] 05 0
因为一个状态的context必须是一个完整的类型（即不可以是前向声明），所以状态机必须是由外而内进行定义，比如，上面秒表的总是从状态机（StopWatch）开始，接下来是外层的状态(Active), 最后才是外层状态的直接内层状态(Running/Stopped)。
秒表的功能已经介绍完成了，如果掌握了，就可以编写由几个状态的简单应用。对于稍多的状态，就需要“数码相机”登场了。一个状态可以由同一个事件触发的多个反应。这个就需要定制化反应。
假设一个数码相机由以下两个控制键，快门键和配置键。快门键分为快按和半按，对应事件为EvShutterHalf, EvShutterFull 和 EvShutterReleased；配置键对应事件为EvConfig。状态机图如下所示：
首先定义基本的事件，EvShutterHalf/EvShutterFull/EvShutterRelease/EvConfig/EvInFocus
class EvShutterHalf : public boost::statechart::event< EvShutterHalf > {};
class EvShutterFull : public boost::statechart::event< EvShutterFull > {};
class EvShutterRelease : public boost::statechart::event< EvShutterRelease > {};
class EvConfig : public boost::statechart::event< EvConfig > {};
class EvInFocus : public boost::statechart::event< EvInFocus > {};
实现数码相机的状态机Camera, 其初始状态为NotShooting
class NotShooting;
class Camera : public boost::statechart::state_machine< Camera, NotShooting >
{
public:
bool IsMemoryAvailable() const { return true; }
bool IsBatteryLow() const { return false; }
};
然后实现NotShooting状态，其初始内层状态为Idle, 注意我们这里使用了定制化反应custom_reaction, 这里只需指定事件，而实际的反应在react成员函数中实现。
class Idle;
class Shooting;
class NotShooting : public boost::statechart::simple_state<NotShooting, Camera, Idle >
{
public:
typedef boost::statechart::custom_reaction< EvShutterHalf > reactions;
boost::statechart::result react( const EvShutterHalf & )
{
LOG(INFO) << "cur NotShooting, receive EvShutterHalf";
return transit< Shooting >();
}
};
实现Idle状态，其外层状态为NotShooting
class Configuring;
class Idle : public boost::statechart::simple_state< Idle, NotShooting >
{
public:
typedef boost::statechart::custom_reaction< EvConfig > reactions;
boost::statechart::result react( const EvConfig & )
{
LOG(INFO) << "cur Idle, receive EvConfig";
return transit< Configuring >();
}
};
实现Configuring状态，其外层状态为NotShooting。
class Configuring : public boost::statechart::simple_state< Configuring, NotShooting >
{
public:
typedef boost::statechart::custom_reaction< EvConfig > reactions;
boost::statechart::result react( const EvConfig & )
{
LOG(INFO) << "cur Configuring, receive EvConfig";
return transit< Idle >();
}
};
实现Shooting状态，所属状态机Camera, Shooting的初始状态为Focusing。
class Focusing;
class Shooting : public boost::statechart::simple_state< Shooting, Camera, Focusing >
{
public:
typedef boost::statechart::custom_reaction< EvShutterRelease > reactions;
boost::statechart::result react( const EvShutterRelease & )
{
LOG(INFO) << "cur Shooting, receive EvShutterRelease";
return transit< Idle >();
}
};
实现Focusing状态，其外层状态为Shooting。
class Focused;
class Focusing : public boost::statechart::simple_state< Focusing, Shooting >
{
public:
typedef boost::mpl::list<
boost::statechart::custom_reaction< EvInFocus >,
boost::statechart::deferral< EvShutterFull >
> reactions;
boost::statechart::result react( const EvInFocus & )
{
LOG(INFO) << "cur Focusing, receive EvInFocus event";
return transit< Focused >();
}
};
实现Focused状态，其外层状态为Shooting。
class Storing;
class Focused : public boost::statechart::simple_state< Focused, Shooting >
{
public:
typedef boost::mpl::list<
boost::statechart::custom_reaction< EvShutterFull >> reactions;
boost::statechart::result react( const EvShutterFull & )
{
if ( context< Camera >().IsMemoryAvailable() )
{
LOG(INFO) << "cur Focused, receive EvShutterFull event";
return transit< Storing >();
}
else
{
std::cout << "Cache memory full. Please wait...\n";
// 表示该事件可以被抛弃，因此，事件分派算法将停止查找反应，并且状态保存为Focused
return discard_event();
}
}
};
实现Storing状态，其外层状态为Shooting。
class Storing : public boost::statechart::simple_state< Storing, Shooting >
{
public:
Storing(){LOG(INFO) << "cur Storing";}
~Storing(){}
};
完成数码相机的所有实现之后，现在就可以开始进行验证效果。
Camera camera;
camera.initiate();
camera.process_event( EvShutterHalf() );
camera.process_event( EvShutterRelease() );
camera.process_event( EvConfig() );
camera.process_event( EvConfig() );
camera.process_event( EvShutterHalf() );
camera.process_event( EvInFocus() );
运行输出的信息如下，发布不同的事件，就会执行不同的反应，并且切换到其他状态。
[boost::statechart::result NotShooting::react(const EvShutterHalf &):344] cur NotShooting, receive EvShutterHalf
[boost::statechart::result Shooting::react(const EvShutterRelease &):385] cur Shooting, receive EvShutterRelease
[boost::statechart::result Idle::react(const EvConfig &):357] cur Idle, receive EvConfig
[boost::statechart::result Configuring::react(const EvConfig &):369] cur Configuring, receive EvConfig
[boost::statechart::result NotShooting::react(const EvShutterHalf &):344] cur NotShooting, receive EvShutterHalf
[boost::statechart::result Focusing::react(const EvInFocus &):401] cur Focusing, receive EvInFocus event
五、总结
至此，已经将基于迁移表实现的状态机，状态机设计模式以及boost statechart中的秒表和数码相机的功能介绍完毕。
迁移表实现的状态机关键点就是状态迁移关系正确存入映射表中，状态机设计模式则关键在于context上下文，其状态会持有该context对象指针，而boost statechart的状态机的实现，关键是要画出正确的状态图，然后依据状态图来定义事件、实现状态机、再实现外层状态，接着再实现内层状态。
这里介绍的状态机相关知识，只能说算是一个入门知识总结，更深入的议题还需要不断学习和实践来加深理解，比如异步状态机、历史、异常处理等。
六、参考资料
- boost startchart指南
- boost startchart原理
- <<敏捷软件开发 : 原则模式与实践>>
