C++笔试题之实现一个定时器

一.定时器(timer)的需求

1.执行定时任务的时,主线程不阻塞,所以timer必须至少持有一个线程用于执行定时任务

2.考虑到timer线程资源的合理利用,一个timer需要能够管理多个定时任务,所以timer要支持增删任务,通过容器储存任务

3.当timer空闲时(即没有任务或执行任务的时刻未到),timer中的线程不应该空转来占用资源,可通过条件变量实现

4.支持重复任务和非重复任务

二.定时器(timer)的实现

#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <map>
#include <mutex>
#include <thread>
#include <iostream>
#include <iomanip>
#include <sstream>

namespace CC
{
using TaskFunc = std::function<void()>;

struct Task
{
    uint64_t id;
    uint64_t period;
    bool repeated;
    TaskFunc func;
    bool removed;
    Task(uint64_t id, uint64_t period, bool repeated, TaskFunc func)
        : id(id), period(period), repeated(repeated), func(func), removed(false)
    {
    }
};

class Timer
{
public:
  Timer() : m_stop(false)
  {
      m_worker = std::thread(&Timer::run, this);
  }
  ~Timer()
  {
      m_stop.store(true);
      m_condition.notify_all();
      m_worker.join();
  }
  uint64_t add(uint64_t period_ms, bool repeated, TaskFunc func)
  {
      uint64_t when = now() + period_ms;
      Task task(m_cur_id, period_ms, repeated, func);
      {
          std::lock_guard<std::mutex> lock(m_tasks_mutex);
          m_tasks.insert({when, task});
      }
      m_condition.notify_all();
      return m_cur_id++;
  }
  // Timer::remove并没有真正的将定时任务删除,仅仅是将removed标志位设置为true,删除操作实际是在Timer::run中进行的。
  // 为什么要这么做?如果在这里如果由Timer::remove来执行m_tasks.erase(it),那么有可能删除的是Timer::run里正在执行的那个任务,这是明显不对的。
  // 所以才采用将removed标志位设置为true的这种做法。
  bool remove(uint64_t id)
  {
      bool flag = false;
      std::lock_guard<std::mutex> lock(m_tasks_mutex);
      std::multimap<uint64_t, Task>::iterator it =
          std::find_if(m_tasks.begin(), m_tasks.end(),
                       [id](const std::pair<uint64_t, Task> &item) -> bool { return item.second.id == id; });
      if (it != m_tasks.end())
      {
          it->second.removed = true;
          flag = true;
      }
      return flag;
  }

  private:
    std::thread m_worker;
    std::atomic<bool> m_stop;
    std::multimap<uint64_t, Task> m_tasks;
    std::mutex m_tasks_mutex;
    std::condition_variable m_condition;
    uint64_t m_cur_id;
    // m_condition.wait之后继续向下执行,此时如果m_stop是true,那么表明timer要被停止了,那线程也要结束,所以一个break跳出最开始的while (true)循环,让线程执行结束。
    // 如果m_stop是false,那表明现有可能有定时任务需要执行了。取出第一个任务m_tasks.begin(),也是按时间排序最靠前的任务。用任务的时刻和当前时刻对比:
    // 如果"时辰已到",那就执行。执行的之后需要注意的是,要将锁释放lock.unlock(),因为继续持有没有任何意义,反而会阻塞住对m_tasks的一些操作。
    // 如果"时辰未到",那就执行m_condition.wait_for,让当前线程休眠,直到std::chrono::milliseconds(task_time - cur_time)这段时间过去或者被唤醒。
    void run()
    {
        while (true)
        {
            std::unique_lock<std::mutex> lock(m_tasks_mutex);
            m_condition.wait(lock, [this]() -> bool { return !m_tasks.empty() || m_stop; });
            if (m_stop)
            {
                break;
            }
            uint64_t cur_time = now();
            std::multimap<uint64_t, Task>::iterator it = m_tasks.begin();
            uint64_t task_time = it->first;
            if (cur_time >= task_time)
            {
                Task &cur_task = it->second;
                if (!cur_task.removed)
                {
                    lock.unlock();
                    cur_task.func();
                    lock.lock();
                    if (cur_task.repeated && !cur_task.removed)
                    {
                        uint64_t when = cur_time + cur_task.period;
                        Task new_task(cur_task.id, cur_task.period, cur_task.repeated, cur_task.func);
                        m_tasks.insert({when, new_task});
                    }
                }
                m_tasks.erase(it);
            }
            else
            {
                m_condition.wait_for(lock, std::chrono::milliseconds(task_time - cur_time));
            }
        }
    }

    uint64_t now() //ms
    {
        auto now = std::chrono::system_clock::now();
        auto duration = now.time_since_epoch();
        return std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
    }
};

} // namespace CC

// 格式化时间,精确到毫秒.
std::string getTimeString()
{
    auto now = std::chrono::system_clock::now();
    auto duration = now.time_since_epoch();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();

    std::time_t time = std::chrono::system_clock::to_time_t(now);
    std::tm *tm = std::localtime(&time);

    std::stringstream ss;
    ss << std::put_time(tm, "%Y-%m-%d %H:%M:%S") << "." << std::setw(3) << std::setfill('0') << millis % 1000;
    return ss.str();
}

// 待执行的任务
void theTask(int id)
{
    std::cout << getTimeString() << " id = " << id << std::endl;
}

int main()
{
    CC::Timer *timer = new CC::Timer();
    timer->add(3000, false, std::bind(theTask, 1));
    uint64_t id = timer->add(2000, true, std::bind(theTask, 2));
    timer->add(1000, true, std::bind(theTask, 3));
    std::this_thread::sleep_for(std::chrono::seconds(3));

    timer->remove(id);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    delete timer;

    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 0;
}

参考链接:https://zhuanlan.zhihu.com/p/668916073

相关推荐
knighthood20013 分钟前
ros中仿真编写launch时robot_state_publisher,output参数
c++·ubuntu·ros
小林熬夜学编程5 分钟前
【Linux系统编程】第四十二弹---多线程编程全攻略:涵盖线程创建、异常处理、用途、进程对比及线程控制
linux·服务器·c语言·开发语言·c++
£suPerpanda14 分钟前
牛客周赛 Round65 补题DEF
开发语言·数据结构·c++·算法·深度优先·动态规划·图论
code .22 分钟前
C++各个版本的主要特性
开发语言·c++·现代c++
玛卡巴卡(努力学习版)32 分钟前
矩阵特殊打印方式
c++·算法·矩阵
hope_wisdom34 分钟前
C++网络编程之IO多路复用(一)
网络·c++·select·io多路复用
MessiGo1 小时前
C/C++ 知识点:重载、覆盖和隐藏
c++
runing_an_min2 小时前
windows运行ffmpeg的脚本报错:av_ts2str、av_ts2timestr、av_err2str => E0029 C4576
c++·windows·ffmpeg·e0029
无敌岩雀2 小时前
C++设计模式结构型模式———桥接模式
c++·设计模式·桥接模式