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這個個東西