使用boost线程定时器作为后台线程来切换主循环程序状态方法2

上一篇的方法主要使用的是：通过线程延时实

现的定时，并且只能定时一次，如果需要对此定时处理，就需要使用下面的定时器；

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

#include "stdafx.h"
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace boost::asio;
using namespace boost;
using namespace std;
 
 
 
//循环状态
enum program_state
{
    state1,
    state2,
    state3,
    state4
};
 
 
/*
 定时器类的作用:将外部类的超时函数传递进来后，在定时器超时函数中进行调用；
 这样类之间的关系，清晰明了
*/
class ctimer
{
private:
    int     _timeout_len;
    bool    _is_remove_when_timeout;//
    boost::function<void()> f;        //委托函数类型为无参数无返回值
    thread* ptrThread;
public:
    //外部函数
    //
    ~ctimer()
    {
        if (ptrThread != NULL)
        {   
            delete this->ptrThread;
            this->ptrThread = NULL;
        }
    }
    template<typename F>
    void InstallTimer(F f, int _timeout_len, bool _is_remove_when_timeout)
    {
        this->_timeout_len = _timeout_len;
        this->_is_remove_when_timeout = _is_remove_when_timeout;
        this->f = f;
        //开启线程
        ptrThread=new thread(bind(&ctimer::setTimer, this));
    }
    void RemoveTimer()
    {   
        this->_is_remove_when_timeout = true;
        this->_timeout_len = 1;
        this->f = NULL;
    }
    //定时器线程工作者函数
    void setTimer()
    {   
 
        io_service m_ios;
 
        //设置定时器，并设置回调函数
        deadline_timer t( m_ios, boost::posix_time::millisec(this->_timeout_len));
        t.async_wait(bind(&ctimer::timeout,this));//回调
     
        //阻塞在这里，等待事件
        m_ios.run();
     
        cout << "thread quit"<<endl;
    }
    //回调函数
    void timeout()
    {   
        //回调函数中调用外部的处理程序
        if (this->f!=NULL)
            this->f();
        if (this->_is_remove_when_timeout == false)
        {
            thread(bind(&ctimer::setTimer, this));
        }
    }
};
 
 
//测试类，工作者主类
class TestClassA
{
public:
    //定时器类对象
    ctimer* ptrTimer;
    TestClassA()
    {
        state = state1;
        ptrTimer = new ctimer;
    }
    ~TestClassA()
    {
        delete ptrTimer;
    }
     
    //主程序当前状态
    program_state state;
 
    //当前状态定时器超时处理函数
    void  TimeoutCallbackPrint()
    {
        printf(" TimeoutCallbackPrint\n");
     
        ptrTimer->RemoveTimer();//直接关闭定时器
        this->state = state2;
    }
    void run()
    {
        while (1)
        {   
            //状态循环扫描
            switch (this->state)
            {
            case state1:
                proc_state1();
                break;
            case state2: break;
            }
 
        }
    }
    //主程序当前状态，处理函数
    void proc_state1()
    {   
        //加入定时器，并将定时器回调函数的需要处理函数传入进去，并将参数传入
        ptrTimer->InstallTimer(bind(&TestClassA::TimeoutCallbackPrint,this),500, false);
 
        //死循环，进行收发处理
        while (this->state == state1)
        {
        }
    }
};
 
int _tmain(int argc, _TCHAR* argv[])
{   
 
    TestClassA *tc = new TestClassA();
    tc->run();//主程序在类中循环
    getchar();
    return 0;
}