『关于』如何编写一个TimeOut程序

[Derekfan]

各位大侠你们好：
我想做的是：我用一个链表接受数据，其中每个链表单元为一个完整数据，现在想做这样的一个事情，在10秒钟内若链表不为空，我则删除链表的最后一个单元。
如何通过线程来编写这个功能呢？麻烦各位看官给点建议。谢谢

[scq2099yt]

在主程序中设置一个定时器，时间为10秒，10秒后调用线程函数，在线程函数中，遍历链表，如果不为空，则移动指针删除最后一个节点，否则什么也不干。

[Derekfan]

[Quote=引用 1 楼 scq2099yt 的回复:]
在主程序中设置一个定时器，时间为10秒，10秒后调用线程函数，在线程函数中，遍历链表，如果不为空，则移动指针删除最后一个节点，否则什么也不干。
[/Quote]
很感谢你的回复，目前我是这样做的：我现在是用settiemer来设置时间的，但是我如何把链表传入回调函数里面呢？因为我回调函数里面是没有参数的呀？所以我写不出来。

[龙凤呈祥焱]

用WaitTable

[nieoding]

从简单来说，既然你是用回调，而不是用类成员函数，那么有两种做法，1.把链表做出全局的，2初始化回调时把链表指针传递过去，回调时再传回来

从复杂来说，这就是一个很普遍的线程回调耦合问题,
上述的处理方法，都会有潜在的线程危险，因为都牵涉到了指针操作。

boost::signal（插槽）设计出来就是为了解决这个问题的。

当然我所说的都是基于标准C++的干净程序。

如果是基于MFC，也可以用MFC里面的消息传递来解决

1. 保存链表的是一个CWnd窗口类，调用CWnd::SetTimer，在CWnd::OnTimer()里面来处理链表,链表是类的成员，当然存取没问题。
2. 保存链表是一个线程CWindThread类，调用::SetTimer,全局回调里面，给CWinThread::m_nThreadID发送线程消息，线程消息处理里面出来链表。

[Derekfan]

[Quote=引用 4 楼 IamNieo 的回复:]
从简单来说，既然你是用回调，而不是用类成员函数，那么有两种做法，1.把链表做出全局的，2初始化回调时把链表指针传递过去，回调时再传回来

从复杂来说，这就是一个很普遍的线程回调耦合问题,
上述的处理方法，都会有潜在的线程危险，因为都牵涉到了指针操作。

boost::signal（插槽）设计出来就是为了解决这个问题的。

当然我所说的都是基于标准C++的干净程序。

如果是基于MFC，也可以用MFC里面的消息传递来解决
…
[/Quote]
首先，很感谢你的热心帮助。
但是如果我想在一个局部变量里面使用的话不知道是否可以呢？因为这个局部变量，但是因为使用了malloc创建，所以必须得使用超时机制来进行对于无法处理的信息进行删除。
现在我对于具体的实现无法完成。
不知各位大侠能否给个具体的例子，让我来模仿。
谢谢

[Derekfan]

[Quote=引用 3 楼 aaronwang81 的回复:]
用WaitTable
[/Quote]
你能否说得清楚些，
我记得在java中有wait与notify的机制，因为我是刚刚接触vc所以不清楚是否有这样的api来进行使用呢？

[cnzdgs]

用全局或者静态变量储存链表指针。

[zhoujianhei]

我想你至少应该有些代码，尽管不完善，大家帮你改改。

[Derekfan]

[Quote=引用 7 楼 cnzdgs 的回复:]
用全局或者静态变量储存链表指针。
[/Quote]
谢谢，明白！

[nieoding]

[Quote=引用 5 楼 Derekfan 的回复:]
但是如果我想在一个局部变量里面使用的话不知道是否可以呢？因为这个局部变量，但是因为使用了malloc创建，所以必须得使用超时机制来进行对于无法处理的信息进行删除。
[/Quote]
这是一个线程之间关于动态创建对象和释放的问题，以前最早的做法是谁创建谁释放，但是逐渐被gc所替代，就是创建管创建，不用管释放，由系统智能回收。java,C#都是这么做的，
C++如何做到呢？就是用智能指针，标准c++里面是用std::auto_ptr,
但是我推荐你去学习一下boost::shared_ptr，这是boost提供的智能指针，可以让程序员不用再担心内存泄漏的问题了，今天时间太晚，明天我会给你写一点范例，让你知道他的使用方法
之前，你可以搜一搜，自己了解一下

[nieoding]

首先我们看看常规的动态创建

int _tmain(int argc, _TCHAR* argv[])
{
	char * buf = new char[1000];
	return 0;
}

buf是动态创建的1000字节缓冲区，这个代码一定是有内存泄漏的，必须加入 delete buf，防止内存泄漏
我们可以修改为boost::shared_ptr

#include <boost/shared_ptr.hpp>
int _tmain(int argc, _TCHAR* argv[])
{
	boost::shared_ptr<char> buf(new char[1000]);
	return 0;
}

这种代码是内存安全的，退出时buf会自动释放

然后我们再看看动态创建对象的传递问题，一样，我们用常规的写法来写一段测试代码，为了方便说明意图，我们模拟一个应用逻辑，我们需要编写一个视频类，定时能产生视频数据，视频数据格式是 数据内容+数据长度：

#include <iostream>
using namespace std;

struct videodata
{
	int datalen;
	char * data;
};

class video
{
public:
	bool newdata(videodata ** result)
	{
		videodata * data = new videodata[1];
		data->datalen = 1024;
		data->data = new char[data->datalen];
		memset(data->data,0x11,data->datalen);
		*result = data;
		return true;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	video v;
	videodata * data;
	if(v.newdata(&data))
	{
		if(data->data)
			delete data->data;
		delete data;
	}
	return 0;
}

可以看到，我们必须小心的维护videodata,有程序逻辑的问题就会导致程序异常或者内存泄漏，这都是传统c++非常头疼又无法避免的问题，接下来我们用boost::shared_ptr来写出安全又漂亮的代码

#include <iostream>
using namespace std;
#include <boost/shared_ptr.hpp>
struct videodata
{
	typedef boost::shared_ptr<videodata> ptr;
	int datalen;
	boost::shared_ptr<char> data;
};

class video
{
public:
	videodata::ptr newdata()
	{
		videodata::ptr data(new videodata);
		data->datalen = 1024;
		data->data.reset(new char[data->datalen]);
		memset(data->data.get(),0x11,data->datalen);
		return data;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	video v;
	videodata::ptr data = v.newdata();
	return 0;
}

是不是代码很短？而且不要管内存的释放问题

[nieoding]

我们再看看boost::signal（插槽）来实现回调
具体的boost::signal教程可以看看http://blog.csdn.net/jq0123/archive/2008/06/30/2598384.aspx

我们给上面的video类加入插槽回调

using namespace std;
#include <boost/shared_ptr.hpp>
#include <boost/signals.hpp>

struct videodata
{
	typedef boost::shared_ptr<videodata> ptr;
	int datalen;
	boost::shared_ptr<char> data;
};
class video
{
public:
	typedef boost::signal<void(videodata::ptr)> _callback;
protected:
	_callback sig_;
public:
	void newdata()
	{
		videodata::ptr data(new videodata);
		data->datalen = 1024;
		data->data.reset(new char[data->datalen]);
		memset(data->data.get(),0x11,data->datalen);
		sig_(data);
	}
	void register_callback(const _callback::slot_type & slot)
	{
		sig_.connect(slot);
	}
};


void mycallback(videodata::ptr data)
{
	cout << "video callback datalen:" << data->datalen << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	video v;
	v.register_callback(mycallback);
	v.newdata();
	return 0;
}

v.newdata()会触发一个回调mycallback产生，可以看到回调传递了一个boost::shared_ptr，他的生命周期你是不用关心的，是内存安全的

[nieoding]

如下程序实现
“ 我想做的是：我用一个链表接受数据，其中每个链表单元为一个完整数据，现在想做这样的一个事情，在10秒钟内若链表不为空，我则删除链表的最后一个单元。 ”

#include <iostream>
using namespace std;
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/signals.hpp>

//////////////////////////////////////////////////////////////////////////
//扩展io_service，去除对单线程io_service:run依赖
class io_service_ex
{
public:
	boost::asio::io_service io;
private:
	boost::asio::deadline_timer timer_;//only used for keep io thread live
	HANDLE event_stop_;
public:
	io_service_ex()
		: timer_(io,boost::posix_time::seconds(1))
		,event_stop_(0)		
	{
		timer_.async_wait(boost::bind(&io_service_ex::handle_timer,this,boost::asio::placeholders::error));
		boost::thread thd(boost::bind(&io_service_ex::control_run,this));
	}
	~io_service_ex()
	{
		event_stop_ = CreateEvent(0,0,0,0);
		io.stop();
		WaitForSingleObject(event_stop_,-1);
	}
	void control_run()
	{
		boost::thread thd(boost::bind(&boost::asio::io_service::run,&io));
		thd.join();
		if(event_stop_)
			SetEvent(event_stop_);
	}
	void handle_timer(const boost::system::error_code er)
	{
		if(er)
			return;
		timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
		timer_.async_wait(boost::bind(&io_service_ex::handle_timer,this,boost::asio::placeholders::error));
	}
};
//////////////////////////////////////////////////////////////////////////
//链表单元结构
struct list_item
{
	typedef boost::shared_ptr<list_item> ptr;
	int datalen;
	boost::shared_ptr<char> data;
};
//////////////////////////////////////////////////////////////////////////
//主程序类，定时维护链表，10秒钟内若链表不为空，则删除链表的最后一个单元
class worker
{
protected:
	vector<list_item::ptr> list_;
	boost::mutex mutex_;
	io_service_ex io_;
	boost::shared_ptr<boost::asio::deadline_timer> timer_;
public:
	worker()
	{
		int sec = 10 * 1000;//定时时间,毫秒单位
		timer_ = boost::shared_ptr<boost::asio::deadline_timer>(new boost::asio::deadline_timer(io_.io,boost::posix_time::milliseconds(sec)));
		timer_->async_wait(boost::bind(&worker::handle_timer,this,boost::asio::placeholders::error,sec));

	}
	void handle_timer(const boost::system::error_code er,int second)
	{
		if(er)
		{
			timer_.reset();
			return;
		}
		onTimer(timer_.get());
		timer_->expires_at(timer_->expires_at() + boost::posix_time::milliseconds(second));
		timer_->async_wait(boost::bind(&worker::handle_timer,this,boost::asio::placeholders::error,second));
	}
	void onTimer(boost::asio::deadline_timer * timer)
	{
		boost::mutex::scoped_lock lock(mutex_);//锁
		if(!list_.empty())
		{
			list_.pop_back();
			cout << "list tail item cleared" << endl;
		}
		else
			cout << "list empty" << endl;
	}
	void push(list_item::ptr item)
	{
		boost::mutex::scoped_lock lock(mutex_);//锁
		list_.push_back(item);
	}
};

boost::shared_ptr<worker> g_worker;
bool parse(string cmd)
{
	if(cmd=="exit")
		return false;
	else if(cmd=="start")
		g_worker.reset(new worker);
	else if(cmd=="stop")
		g_worker.reset();
	else if(cmd=="push")
	{
		list_item::ptr item(new list_item);
		item->datalen = 100;
		item->data.reset(new char[item->datalen]);
		g_worker->push(item);
	}
	return true;
}

int _tmain(int argc, _TCHAR* argv[])
{
	char buf[100];
	while(true)
	{
		gets_s(buf,sizeof buf);
		if(!parse(buf))
			break;
	}
	return 0;
}

当然，本身这个命题也完全不需要用这么新鲜的技术来解决，用mfc完全也可实现，
我只是希望读者能够通过一个简单的命题切入，领悟到boost写高效程序的优越性。
本程序用到了如下技术：
boost::asio::deadline_timer 定时器
boost::bind 先进的函数绑定
boost::thread 简单扼要的线程
boost::mutex 干净的线程锁
boost::shared_ptr 智能指针