C/C++编程：C++11实现简易定时器

我就是我 2023-02-25 14:25 8阅读 0赞

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

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

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

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

timer.hpp

#ifndef _TIMER_H_
    #define _TIMER_H_
    
    #include <functional>
    #include <chrono>
    #include <thread>
    #include <atomic>
    #include <memory>
    #include <mutex>
    #include <condition_variable>
    
    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<void()> 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<std::mutex> locker(_mutex);
    				_expired = true;
    				_expired_cond.notify_one();
    			}
    		}).detach();
    	}
    
    	void startOnce(int delay, std::function<void()> 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<std::mutex> locker(_mutex);
    			_expired_cond.wait(locker, [this] {
        return _expired == true; });
    
    			// reset the timer
    			if (_expired == true)
    				_try_to_expire = false;
    		}
    	}
    
    private:
    	std::atomic<bool> _expired; // timer stopped status
    	std::atomic<bool> _try_to_expire; // timer is in stop process
    	std::mutex _mutex;
    	std::condition_variable _expired_cond;
    };
    
    #endif // !_TIMER_H_

如何使用：

#include <iostream>
    #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;
    }