c++11 写一个定时器模型

已于 2023-12-11 19:34:14 修改
阅读量296 收藏 4
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 算法
于 2023-03-24 19:41:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_31872269/article/details/129757295
版权

1：单个线程可以添加多个定时器
2：完全依赖c++11
3：添加删除定时器是同步的

头文件
WorkerThread.h

#ifndef WorkerThread_H_
#define WorkerThread_H_
#include <functional>
#include <stdint.h>
#include <stdio.h>
#include <list>
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable>
#include <map>
#include <future>

#include <stdint.h>
#include <string>



class Event
{
public:
	int64_t Wait()
	{
		std::unique_lock<decltype(m_MutexCondition)> lock{ m_MutexCondition };
		m_Condition.wait(lock, [&]()->bool { return ret != -1; }); // suspend and wait ...	
		return ret;
	}
	void Set(int64_t re)
	{
		std::unique_lock<decltype(m_MutexCondition)> lock(m_MutexCondition);
		ret = re;
		m_Condition.notify_one();
	}
	std::mutex m_MutexCondition;
	std::condition_variable m_Condition;
	int64_t ret = -1;
};
class Timer
{
public:
	Timer(int64_t delay, std::function<bool()> cb) : m_iDelay(delay), m_cb(cb) {};
	~Timer() {};
	int64_t m_iDelay = 0;
	std::function<bool()> m_cb;
	int64_t m_iTimerId = -1;
};

using Task = std::function<void()>; //定义类型


class WorkerThread
{
public:
	WorkerThread();

	int32_t StartRun();
	void StopRun();
	~WorkerThread();


public:

	// 添加一个定时器
	int64_t AddTimer(int64_t iDelayUs, std::function<bool()> fcb);
	// 删除一个定时器
	int32_t DelTimer(int64_t timerId);

	// 异步任务
	void PostTask(Task task);
	// 同步执行任务
	void InvokTask(Task task);
	
private:
	void RunLoop();
	int64_t getCurrentTicket();
	int32_t addTimerInner(std::shared_ptr<Timer>& _Timer);
	int32_t delTimerInner(int64_t timerId);

	int64_t flushDelayTask(uint64_t now_time);

	int64_t getMinDelay();

private:
	std::multimap<uint64_t, std::shared_ptr<Timer> > m_delayTask;
	std::mutex _mutex;
	std::condition_variable _condition;
	bool m_bStart = false;
	int64_t m_iTimerId = 0;

	std::list<Task> _queue;

	std::thread* m_loopThread = NULL;
	bool m_bExitThread = false;
	std::thread::id _loopThreadId;
};


class EventLoop
{
public:
	EventLoop(const EventLoop&) = delete;
	EventLoop& operator = (const EventLoop&) = delete;
	EventLoop(uint32_t num_threads = 1);  //std::thread::hardware_concurrency()
	virtual ~EventLoop();

	std::shared_ptr<WorkerThread> GetTaskScheduler();

	// 添加一个定时器
	int64_t AddTimer(int64_t iDelayUs, std::function<bool()> fcb);
	// 删除一个定时器
	int32_t DelTimer(int64_t timerId);

	// 异步任务
	void PostTask(Task task);
	// 同步执行任务
	void InvokTask(Task task);

	void Loop();
	void Quit();

private:
	std::mutex mutex_;
	uint32_t num_threads_ = 1;
	uint32_t index_ = 1;
	std::vector<std::shared_ptr<WorkerThread>> task_schedulers_;
	
};
#endif

WorkerThread.cpp 文件

#include "WorkerThread.h"


WorkerThread::WorkerThread()
{
}
WorkerThread::~WorkerThread()
{
	StopRun();
}

int64_t WorkerThread::getCurrentTicket()
{
	//std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
	//std::chrono::steady_clock::time_point t11;
	//int64_t duration = std::chrono::duration_cast<std::chrono::microseconds>(t1 - t11).count();
	//int64_t duration = std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t11).count();
	return  std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
}
int32_t WorkerThread::StartRun()
{
	m_loopThread = new std::thread(&WorkerThread::RunLoop, this);
	std::unique_lock<std::mutex> lock(_mutex);
	_condition.wait(lock, [this]() { return m_bStart == true; });

	if (m_loopThread)
	{
		return 0;
	}
	return -1;

}
void WorkerThread::StopRun()
{
	m_bExitThread = true;
	{
		std::unique_lock<std::mutex> lock(_mutex);
		_queue.push_back([]() {int a; });
	}
	_condition.notify_one();

	if (m_loopThread)
	{
		m_loopThread->join();
		delete m_loopThread;
		m_loopThread = 0;
	}
}

int64_t WorkerThread::AddTimer(int64_t iDelay, std::function<bool()> fcb)
{

	//using RetType = decltype(int32_t(Timer&&)); // typename std::result_of<F(Args...)>::type, 函数 f 的返回值类型
#if 0
	auto t_timer = std::make_shared<Timer>(iDelay, fcb);

	auto task = std::make_shared<std::packaged_task<int64_t(std::shared_ptr<Timer>)>>(
		bind(&WorkerThread::addTimerInner, this, (t_timer)));


	std::future<int64_t> future = task->get_future();

	{
		std::lock_guard<std::mutex> lock(_mutex);
		_queue.push_back([task]() {
			std::shared_ptr<Timer> a;
			(*task)(a);
			});
	}
	_condition.notify_one();
	int32_t ret = future.get();
	return ret;
#else

	Event tEvent;
	auto t_timer = std::make_shared<Timer>(iDelay, fcb);
	{
		std::unique_lock<std::mutex> lock(_mutex);
		_queue.push_back([this, &t_timer, &tEvent]() {
		

			m_iTimerId++;
			t_timer->m_iTimerId = m_iTimerId;
			uint64_t time_line = getCurrentTicket() + t_timer->m_iDelay;
			m_delayTask.emplace(time_line, std::move(t_timer));

			tEvent.Set(m_iTimerId);
			});
	}
	_condition.notify_one();
	return tEvent.Wait();
#endif

}

void WorkerThread::PostTask(Task task)
{
	{
		std::unique_lock<std::mutex> lock(_mutex);
		Event tEvent;
		_queue.push_back([task]() {
			task();

			});
	}
	_condition.notify_one();
}

void WorkerThread::InvokTask(Task task)
{
	Event tEvent;
	{
		std::unique_lock<std::mutex> lock(_mutex);
		_queue.push_back([task, &tEvent]() {
			task();
			tEvent.Set(0);
			});
	}
	_condition.notify_one();
	printf("Wait before \n");
	tEvent.Wait();
}
int32_t WorkerThread::DelTimer(int64_t timerId)
{

#if 0
	auto task = std::make_shared<std::packaged_task<int32_t(int32_t)>>(
		std::bind(&WorkerThread::delTimerInner, this, (timerId)));

	std::future<int32_t> future = task->get_future();

	{
		std::lock_guard<std::mutex> lock(_mutex);
		_queue.push_back([task]() {
			(*task)(0);
			});

	}
	_condition.notify_one();
	int32_t ret = future.get();
	return ret;
#else



	Event tEvent;

	{
		std::unique_lock<std::mutex> lock(_mutex);
		_queue.push_back([&tEvent, timerId, this]() {
			
			std::multimap<uint64_t, std::shared_ptr<Timer> >::iterator it = m_delayTask.begin();
			for (; it != m_delayTask.end();)
			{
				std::shared_ptr<Timer> pTimer = it->second;
				if (pTimer->m_iTimerId == timerId)
				{
					it = m_delayTask.erase(it);
					tEvent.Set(0);
					return;
				}
				else
				{
					it++;
				}
			}
			tEvent.Set(1);
			return;
			});

	}
	_condition.notify_one();
	
	return tEvent.Wait();

#endif
}


void WorkerThread::RunLoop()
{
	_loopThreadId = std::this_thread::get_id();
	m_bStart = true;
	_condition.notify_one();

	while (!m_bExitThread)
	{
		int64_t delay = getMinDelay(); // 处理定时器任务

		std::list<Task> t_queue;
		{
			std::unique_lock<std::mutex> lock(_mutex);
			//_condition.wait_for(lock, std::chrono::milliseconds(delay), [this]() { return !_queue.empty(); });
			_condition.wait_for(lock, std::chrono::microseconds(delay), [this]() { return !_queue.empty(); });
			if (!_queue.empty())
			{
				t_queue.swap(_queue);

			}
		}
		// 处理任务
		if (!t_queue.empty())
		{
			for (std::list<Task>::iterator it = t_queue.begin(); it != t_queue.end(); it++)
			{
				Task task = *it;
				task();
			}
			t_queue.clear();
		}
	}

}


int32_t WorkerThread::addTimerInner(std::shared_ptr<Timer>& _Timer)
{
	printf("delay:%lld \n", _Timer->m_iDelay);
	m_iTimerId++;
	_Timer->m_iTimerId = m_iTimerId;
	uint64_t time_line = getCurrentTicket() + _Timer->m_iDelay;
	m_delayTask.emplace(time_line, std::move(_Timer));

	return m_iTimerId;

}


int32_t WorkerThread::delTimerInner(int64_t timerId)
{
	std::multimap<uint64_t, std::shared_ptr<Timer> >::iterator it = m_delayTask.begin();

	for (; it != m_delayTask.end();)
	{
		std::shared_ptr<Timer> pTimer = it->second;
		if (pTimer->m_iTimerId == timerId)
		{
			it = m_delayTask.erase(it);
			return 0;
		}
		else
		{
			it++;
		}
	}
	return -1;
}

int64_t WorkerThread::getMinDelay() {
	auto it = m_delayTask.begin();
	if (it == m_delayTask.end()) {
		//没有剩余的定时器了
		return 0;
	}
	auto now = getCurrentTicket();
	if (it->first > now) {
		//所有任务尚未到期
		return it->first - now;
	}
	//执行已到期的任务并刷新休眠延时
	return flushDelayTask(now);
}

int64_t WorkerThread::flushDelayTask(uint64_t now_time) {

	//printf("############# sleep :%llu \n", now_time);
	decltype(m_delayTask) taskCopy;
	taskCopy.swap(m_delayTask);
	uint64_t start = getCurrentTicket();
	for (auto it = taskCopy.begin(); it != taskCopy.end() && it->first <= now_time; it = taskCopy.erase(it)) {
		//已到期的任务
		try {
			//auto next_delay = (*(it->second))();
			std::shared_ptr<Timer>  pTimer = it->second;
			if (pTimer->m_cb)
			{
				bool ret = pTimer->m_cb();
				if (ret)
				{
					m_delayTask.emplace(pTimer->m_iDelay + now_time, std::move(it->second));
				}
			}
		}
		catch (std::exception& ex) {
			//ErrorL << "EventPoller执行延时任务捕获到异常:" << ex.what();
		}
	}
	uint64_t end = getCurrentTicket();
	int64_t useTime = end - start;
	if (useTime > 11)
	{
		//printf("timers_poll::flushDelayTask useTimer = %d \n", useTime);
	}

	taskCopy.insert(m_delayTask.begin(), m_delayTask.end());
	taskCopy.swap(m_delayTask);

	auto it = m_delayTask.begin();
	if (it == m_delayTask.end()) {
		//没有剩余的定时器了
		return 0;
	}
	//最近一个定时器的执行延时

	int64_t t_sleep = it->first - getCurrentTicket();
	if (t_sleep < -1)
	{
		printf("timers_poll::flushDelayTask  t_sleep = %lld  \n", t_sleep);
	}
	return t_sleep > 0 ? t_sleep : 0;

}



EventLoop::EventLoop(uint32_t num_threads)
	: index_(1)
{
	num_threads_ = 1;
	if (num_threads > 0) {
		num_threads_ = num_threads;
	}

	this->Loop();
}

EventLoop::~EventLoop()
{
	this->Quit();
}

std::shared_ptr<WorkerThread> EventLoop::GetTaskScheduler()
{
	std::lock_guard<std::mutex> locker(mutex_);
	if (task_schedulers_.size() == 1) {
		return task_schedulers_.at(0);
	}
	else {
		auto task_scheduler = task_schedulers_.at(index_);
		index_++;
		if (index_ >= task_schedulers_.size()) {
			index_ = 1;
		}
		return task_scheduler;
	}

	return nullptr;
}

int64_t EventLoop::AddTimer(int64_t iDelayUs, std::function<bool()> fcb)
{
	std::lock_guard<std::mutex> locker(mutex_);
	if (task_schedulers_.size() > 0) {
		return task_schedulers_[0]->AddTimer(iDelayUs, fcb);
	}
	return -1;
}

int32_t EventLoop::DelTimer(int64_t timerId)
{
	std::lock_guard<std::mutex> locker(mutex_);
	if (task_schedulers_.size() > 0) {
		return task_schedulers_[0]->DelTimer(timerId);
	}
	return -1;
}

void EventLoop::PostTask(Task task)
{
	std::lock_guard<std::mutex> locker(mutex_);
	if (task_schedulers_.size() > 0) {
		task_schedulers_[0]->PostTask(task);
	}

}

void EventLoop::InvokTask(Task task)
{
	std::lock_guard<std::mutex> locker(mutex_);
	if (task_schedulers_.size() > 0) {
		return task_schedulers_[0]->InvokTask(task);
	}
	return;
}

void EventLoop::Loop()
{
	std::lock_guard<std::mutex> locker(mutex_);

	if (!task_schedulers_.empty()) {
		return;
	}

	for (uint32_t n = 0; n < num_threads_; n++)
	{
		std::shared_ptr<WorkerThread> task_scheduler_ptr(new WorkerThread());
		task_scheduler_ptr->StartRun();
		task_schedulers_.push_back(task_scheduler_ptr);

	}

}

void EventLoop::Quit()
{
	std::lock_guard<std::mutex> locker(mutex_);

	for (auto iter : task_schedulers_) {
		iter->StopRun();
	}
	task_schedulers_.clear();

}

main.cpp

// condition_variable.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include "WorkerThread.h"


int main()
{

    WorkerThread tWorkerThread;
    tWorkerThread.StartRun();

    Event tEvern;
    tWorkerThread.PostTask([&tEvern]() {
        printf("$$$$$$$$$$$$ \n");
        
        tEvern.Set();
        });


    tEvern.Wait();
    printf("over \n");


    tWorkerThread.InvokTask([]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        });
    printf("over 1 \n");
    getchar();
    std::cout << "Hello World!\n";
}
LIZhang2016
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于C++11实现的定时器
11-18
分享一个基于C++11实现的定时器，当有多个定时任务时，向定时器里面添加定时任务，定时器到时间自动执行事件，编译环境(GCC) 4.7.2
C/C++ 定时器程序（含源码和demo）
07-28
总结来说，这个C/C++定时器程序是一个宝贵的资源，不仅提供了实践机会，还能帮助我们深入理解操作系统级别的定时器实现，以及跨平台开发的技巧。通过学习和使用这个程序，我们的编程能力将得到显著提升。
C++11实现简易定时器
踏莎行的博客
05-05 8988
定时器timer是多线程编程中经常设计到的工具类 定时器的原理其实很简单： 创建一个新线程 在那个线程里等待 等待指定时长后后做任务 这里用C++11实现了一个简单易用的定时器，包含两种模式： 周期性定时任务执行 单次延时任务执行 timer.hpp #ifndef _TIMER_H_ #define _TIMER_H_ #include <functional> #incl...
C++ 定时器任务的多种实现方法详解
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-19 1390
在现代编程中，定时器任务（Timer Task）是一项常见且重要的功能。无论是在嵌入式系统、网络应用，还是桌面软件开发中，定时器任务都能帮助我们在指定时间点或时间间隔内执行特定操作。本文将详细介绍几种在 C++ 中实现单次定时器任务的方法，帮助开发者在不同的应用场景中选择合适的解决方案。
C++11 定时器
zhuxian2009的专栏
09-14 2028
【代码】C++11 定时器。
C++11实现的简单定时器
sl8023dxf的专栏
10-11 216
class SimpleTimer { public: SimpleTimer() { } ~SimpleTimer() { m_bStop = true; if (m_pThread) { m_pThread->join(); delete m_pThread; } } unsigned int Interval() const { return m_uiMsecInterval; } void Interval(unsigned int ui
C++11实现的定时器
音视频技术之路QQ_1695710968
11-18 2108
分享一个基于C++11实现的定时器，当有多个定时任务时，向定时器里面添加定时任务，定时器到时间自动执行事件，编译环境(GCC) 4.7.2 ，参考代码 Timer.h #ifndef _X_TIMER_H #define _X_TIMER_H #include &lt;map&gt; #include &lt;unordered_map&gt; #include &lt;chrono&gt...
纯C++11的timer定时器
weixin_43360707的博客
05-26 676
如题所示，最近看mlu代码的时候发现了一个非常号的定时器案例，纯c++，只有一个头文件，非常好。
基于C++11的高精度多级时间轮定时器
鳴海步的博客
12-18 5760
定时器通常包括至少两个成员：一个超时时间（通常采用相对时间或者超时时间）和一个超时时间到达后的一个回调函数。有时候还可能包括回调函数被运行时须要传入的参数，以及是否又一次启动定时器，更改定时器的超时时间等。假设使用链表作为容器来串联全部的定时器。则每一个定时器还要包括指向下一个定时器的指针成员。进一步，假设链表是双向的，则每一个定时器还须要包括指向前一个定时器的指针成员。基于排序链表的定时器使用唯一的一条链表来管理所有的定时器，所以插入操作的效率随着定时器的数目增多而降低。而时间轮使用了哈希表处理冲突的思想
一个定时器实现多个虚拟定时器具体代码实现
03-23
这可能是一个结构体或类，每个实例代表一个虚拟定时器。 2. **时间管理**：为了比较和管理多个定时器的触发时间，需要一个数据结构（如优先队列）来按时间顺序排列所有定时器。这样可以在每次检查时快速找到即将...
c++定时器，用于vs
02-28
这些定时器基于异步IO模型，可以在未来的某个时间点触发一个回调函数。例如，你可以创建一个steady_timer，设定一个时间点，当时间到达时，会触发一个预先绑定的handler。Boost库跨平台，且提供了丰富的功能，但需要...
C++ timer定时器模板类 使用CreateTimerQueueTimer
01-22
使用CreateTimerQueueTimer实现的C++定时器模板类，适合在Windows下的C++开发，作为Timer工具类，使用简单。
标准c++11 实现的计时器
08-26
这是一个标准c++11实现的可移植的计时器。合适跨平台使用。
C++实现鼠标左键控制摄像机旋转模型，六视图切换，模型自动旋转
01-12
模型的自动旋转功能则需要一个定时器来周期性地改变模型的旋转角度。在OpenGL中，我们可以使用旋转矩阵或四元数来表示和更新模型的旋转状态。通过在每个渲染帧中增加旋转角度，模型会连续地围绕指定轴旋转。 在实际...
c++实现 mfc做一个正方体对他着色并且可以环绕浏览
06-26
在本项目中，我们利用Microsoft Foundation Classes (MFC) 和C++来实现一个三维正方体的绘制，并对其进行着色，同时实现正方体的环绕浏览效果。MFC是微软提供的一种C++类库，它封装了Windows API，使得开发Windows...
C++11实现简易定时器的示例代码
lu_linux的博客
11-26 479
定时器timer是多线程编程中经常设计到的工具类 定时器的原理其实很简单： 创建一个新线程 在那个线程里等待 等待指定时长后做任务 这里用C++11实现了一个简单易用的定时器，包含两种模式： 周期性定时任务执行 单次延时任务执行 timer.hpp文件 #ifndef _TIMER_H_ #define _TIMER_H_ #include <functional> #include <chrono> #include <thread> #include
c++ 定时器使用
http://www.softwareace.cn 王牌软件
08-30 803
c++ 定时器使用   1.1   用WM_TIMER来设置定时器 先请看SetTimer这个API函数的原型 UINT_PTR   SetTimer( HWND   hWnd,   //   窗口句柄 UINT_PTR   nIDEvent,
c++定时器
热门推荐
qq_36583051的博客
07-30 1万+
记录一下，防止忘记 定时器timer是多线程编程中经常设计到的工具类 定时器的原理其实很简单： 创建一个新线程 在那个线程里等待 等待指定时长后做任务 这里用C++11实现了一个简单易用的定时器，包含两种模式： 周期性定时任务执行 单次延时任务执行 #ifndef _TIMER_H_ #define _TIMER_H_ #include <functional> #include <chrono> #include <thread> #include &l
用c++写一个线程安全事件驱动的定时器类
03-31
抱歉，由于我是一个语言模型AI，无法在本地编写和测试代码，以下是一个线程安全的事件驱动定时器类的代码示例，供您参考： #include #include #include #include #include #include using namespace std; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值