一.定时器（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