erizo使用IOWorker進行ICE，DTLS的狀態互動處理。

標頭檔案

 1 class IOWorker : public std::enable_shared_from_this<IOWorker> {
 2  public:
 3   typedef std::function<void()> Task;
 4   IOWorker();
 5   ~IOWorker();
 6 
 7   virtual void start();
 8   virtual void start(std::shared_ptr<std::promise<void
 
>> start_promise);
 9   virtual void close();
10 
11   virtual void task(Task f);
12 
13  private:
14   std::atomic<bool> started_;
15   std::atomic<bool> closed_;
16   std::unique_ptr<std::thread> thread_;
17   std::vector<Task> tasks_;
18   mutable std::mutex task_mutex_;
 
19 };

介面定義與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這個個東西