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

 

  1：简单了解boost定时器

#include "stdafx.h"
#include <string>
#include <boost\thread.hpp>
#include <boost/asio.hpp>
#include <iostream>
using namespace boost::asio;
using namespace boost;
int exit1 = 1;
void printing(int& len)
{
    this_thread::sleep_for(chrono::seconds(len));//线程中阻塞定时后改变系统状态
    len++;
    exit1 = 0;
}
int _tmain(int argc, _TCHAR* argv[])
{    
    //绑定简单函数
    int len = 2;
    thread(printing, len);//默认构造函数都是复制值传递，如果要使用引用传递请使用
    //thread(printing, ref(len));
    while (exit1);//线程中定时后改变系统阻塞的状态；
    printf("ddd");
    getchar();
    return 0;
}

 2：使用bind方法

#include <string>
#include <boost\thread.hpp>
#include <boost/asio.hpp>
#include <iostream>
using namespace boost::asio;
using namespace boost;
int exit1 = 1;
void printing(int& len, const char * str)
{        
    printf("%s", str);
    this_thread::sleep_for(chrono::seconds(len));//线程中阻塞定时后改变系统状态
    len++;

    exit1 = 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    thread(bind(printing, 2, "thread runing"));//使用bind函数将函数绑定为一个函数对象
    while (exit1);//线程中定时后改变系统阻塞的状态；
    printf("ddd");
    getchar();
    return 0;
}

3：使用类的处理方式(核心哦)

说明：(1)前面两种主要是基本使用方法，而方法3已经用在了实际工程开发中，方法3主要涉及的一种状态转化的框架，在每种状态下，都有一个while死循环的进行网络或者通信口的数据读写，当满足某种条件时，进行状态的跳转；while是阻塞而线程定时器则作为后台进行状态的转化；

(2)本文的线程定时器应该叫做线程延时器,主要是在后台运行；线程成为工作者函数或者程序工作者方法；线程中延时结束后，会调用本类的成员函数作为回调处理；

(3)如果某个状态不更新，则只需要在回调中再次进行开启线程即可；

(4)当然建议使用Bind方式绑定工作者方法，否则就要设置工作函数为静态方法，还得使用reinterpret_cast强制转换指针；

(5)关于reinterpret_cast，我的理解就是"能将this指针参数强制转化为this"，从而达到可以成员函数的目的；

(6)最关键的所有的操作使用的boost,本文用的编译工具是VS2013；

 

/*线程定时器在类中使用,需要注意的是：
(1)此时必须使用“绑定成员函数”的方式给thread传入工作者线程方法，否则不能编译通过，使用这种方法好处在于工作者线程不必是静态函数；
(2)如果不采用bind方式，则必须需要将“工作者线程设置为静态函数”,另加入this指针，使用这种方法比较this指针获取比较难理解，并且工作者函数必须是静态函数;

*/


#include "stdafx.h"
#include <string>
#include <boost\thread.hpp>
#include <boost/asio.hpp>
#include <iostream>
using namespace boost::asio;
using namespace boost;

enum program_state
{
	state1,
	state2,
	state3,
	state4
};
class TestClassA
{
public:
	TestClassA()
	{
		state = state1;
	}
	program_state state;
	void  TimeoutPrint(int& len, const char * str);
	void  TimeoutCallbackPrint();
	void run();
	void proc_state1();
	void proc_state2();
	void static StaticTimeoutPrint(int& len, const char * str,void* This);


};
void TestClassA::TimeoutPrint(int& len, const char * str)
{
	printf("%s in\n", str);
	this_thread::sleep_for(chrono::seconds(len));//线程中阻塞定时后改变系统状态
	printf("%s out\n", str);
	//直接使用this指针就能调用回调函数
	this->TimeoutCallbackPrint();
}
void TestClassA::TimeoutCallbackPrint()
{
	this->state = state2;
	printf(" TimeoutCallbackPrint\n");
}
void TestClassA::proc_state1()
{	
	//采用绑定成员函数的方式,注意绑定成员函数时，需要一个占位符，提供类实例、引用或者指针
	thread(bind(&TestClassA::TimeoutPrint,this, 5, "thread 1"));
	while (this->state == state1)
	{
	}
}
void TestClassA::StaticTimeoutPrint(int& len, const char * str,void* This)
{
	printf("%s in\n", str);
	this_thread::sleep_for(chrono::seconds(len));//线程中阻塞定时后改变系统状态
	printf("%s out\n", str);
	//this指针需要强制转换才能访问成员函数
	((reinterpret_cast<TestClassA*>(This)))->TimeoutCallbackPrint();
}
void TestClassA::proc_state2()
{
	//采用静态函数方式
	thread(TestClassA::StaticTimeoutPrint, 5, "thread 2",this);
	while (this->state == state2)
	{
	}
}
void TestClassA::run()
{
	while (1)
	{
		switch (this->state)
		{
			case state1:
				proc_state1();
				break;
			case state2:
				proc_state2(); break;
		}

	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	TestClassA *tc = new TestClassA();
	tc->run();
	return 0;
}