licode学习之erizo篇--IOWorker

erizo使用IOWorker进行ICE，DTLS的状态交互处理。

头文件

class IOWorker : public std::enable_shared_from_this<IOWorker> {
 public:
  typedef std::function<void()> Task;
  IOWorker();
  ~IOWorker();

  virtual void start();
  virtual void start(std::shared_ptr<std::promise<void>> start_promise);
  virtual void close();

  virtual void task(Task f);

 private:
  std::atomic<bool> started_;
  std::atomic<bool> closed_;
  std::unique_ptr<std::thread> thread_;
  std::vector<Task> tasks_;
  mutable std::mutex task_mutex_;
};

接口定义与Worker基本没有区别，但是内部使用了atomic变量，而没有使用boost的io service，说明线程的执行是自己控制的，看看具体实现

主要看线程执行体以及task方法

void IOWorker::start(std::shared_ptr<std::promise<void>> start_promise) {
  if (started_.exchange(true)) {
    return;
  }

  thread_ = std::unique_ptr<std::thread>(new std::thread([this, start_promise] {
    start_promise->set_value();
    while (!closed_) {
      int events;
      struct timeval towait = {0, 100000};
      struct timeval tv;
      int r = NR_async_event_wait2(&events, &towait);
      if (r == R_EOD) {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
      }
      gettimeofday(&tv, 0);
      NR_async_timer_update_time(&tv);
      std::vector<Task> tasks;
      {
        std::unique_lock<std::mutex> lock(task_mutex_);
        tasks.swap(tasks_);
      }
      for (Task &task : tasks) {
        task();
      }
    }
  }));
}

void IOWorker::task(Task f) {
  std::unique_lock<std::mutex> lock(task_mutex_);
  tasks_.push_back(f);
}

在start里面做了重入检测判断，如果重入，直接返回。

在线程函数体内部，进行了定时处理，即sleep一段时间，执行所有的task。

在task函数中，将Task放入vector中，从总体实现上，与worker有很大的区别，但是从使用角度，基本是无差别的。

搞不清楚为啥弄的风格相差这么多。

在IOWorker里面，使用效率可能不如Worker的效率高，而且人为的将任务集中执行，可能造成瞬时cpu过高。

总体上和worker没有差别，感觉应该能够和worker进行合并，不需要IOWorker这个个东西