c++定时器

记录一下，防止忘记

定时器timer是多线程编程中经常设计到的工具类
定时器的原理其实很简单：

• 创建一个新线程
• 在那个线程里等待
• 等待指定时长后做任务

这里用C++11实现了一个简单易用的定时器，包含两种模式：

• 周期性定时任务执行
• 单次延时任务执行

#ifndef _TIMER_H_
#define _TIMER_H_

#include 
#include 
#include 
#include 
#include 
#include 
#include 

class Timer
{
public:
	Timer(): _expired(true), _try_to_expire(false)
	{}

	Timer(const Timer& timer)
	{
		_expired = timer._expired.load();
		_try_to_expire = timer._try_to_expire.load();
	}

	~Timer()
	{
		stop();
	}

	void start(int interval, std::function task)
	{
		// is started, do not start again
		if (_expired == false)
			return;

		// start async timer, launch thread and wait in that thread
		_expired = false;
		std::thread([this, interval, task]() {
			while (!_try_to_expire)
			{
				// sleep every interval and do the task again and again until times up
				std::this_thread::sleep_for(std::chrono::milliseconds(interval));
				task();
			}

			{
				// timer be stopped, update the condition variable expired and wake main thread
				std::lock_guard locker(_mutex);
				_expired = true;
				_expired_cond.notify_one();
			}
		}).detach();
	}

	void startOnce(int delay, std::function task)
	{
		std::thread([delay, task]() {
			std::this_thread::sleep_for(std::chrono::milliseconds(delay));
			task();
		}).detach();
	}

	void stop()
	{
		// do not stop again
		if (_expired)
			return;

		if (_try_to_expire)
			return;

		// wait until timer 
		_try_to_expire = true; // change this bool value to make timer while loop stop
		{
			std::unique_lock locker(_mutex);
			_expired_cond.wait(locker, [this] {return _expired == true; });

			// reset the timer
			if (_expired == true)
				_try_to_expire = false;
		}
	}

private:
	std::atomic _expired; // timer stopped status
	std::atomic _try_to_expire; // timer is in stop process
	std::mutex _mutex;
	std::condition_variable _expired_cond;
};

#endif // !_TIMER_H_

main.cpp

#include 
#include "timer.hpp"

void func1()
{
	std::cout << "trigger func1" << std::endl;
}

void func2(int x)
{
	std::cout << "trigger func2, x: " << x << std::endl;
}

int main(int argc, char* argv[])
{
	Timer timer;

	// execute task every timer interval
	std::cout << "--- start period timer ----" << std::endl;
	timer.start(1000, std::bind(func2, 3));
	std::this_thread::sleep_for(std::chrono::milliseconds(5000));
	timer.stop();
	std::cout << "--- stop period timer ----" << std::endl;

	// execute task once after delay
	std::cout << "--- start one shot timer ----" << std::endl;
	timer.startOnce(1000, func1);
	std::cout << "--- stop one shot timer ----" << std::endl;

	getchar();
	return 0;
}

运行结果：

--- start period timer ----
trigger func2, x: 3
trigger func2, x: 3
trigger func2, x: 3
trigger func2, x: 3
trigger func2, x: 3
--- stop period timer ----
--- start one shot timer ----
--- stop one shot timer ----
trigger func1