1.初始化

Windows上需要自己初始化系統網路庫，即呼叫

WSADATA WSAData;
WSAStartup(0x201, &WSAData);

結束使用時再

WSACleanup();

另外還需要初始化執行緒設定
windows上
evthread_use_windows_threads
linux上
evthread_use_pthreads

綜上，使用其它libevent的函式前需要這樣：

#if defined(WIN32)
  WSADATA WSAData;
  WSAStartup(0x201, &WSAData);
  evthread_use_windows_threads();
#else
 

  evthread_use_pthreads();
#endif

2.Loop

因為event_base_loop在沒有event的時候就會結束，所以作為事件迴圈，需要加一個超時時間很長的timer event作為預設的負載，在真正結束事件迴圈的時候再把這個event delete掉。

3.Timer

event_new出來的物件是需要自己釋放的，而且無法從event_base裡再獲取所有的還沒執行的events，所以需要把event*儲存起來，執行後再event_del。也就是需要自己做一個封裝，callback函式的arg肯定不會是目標的物件。

4.多執行緒

libevent即使提供了多執行緒初始化函式，它也不能簡單地跨執行緒發訊息。一般來說會想當然地在當前執行緒中對另一個執行緒中的event_base加入一個超時為0的timer event，這樣就會在另一個執行緒執行那個事件，達到發執行緒訊息的效果。然而如果短時間內連續這樣做，這些timer events並不能保證按序執行。
安全的做法是：

1. 每個執行緒建立自己的訊息佇列，發執行緒訊息就是往佇列增加一個訊息。當然，這個過程得加鎖。
2. 建立一對互相連線好的socket，執行緒的event_base加入event監聽EV_READ事件，觸發就按序執行訊息佇列。
3. 每發一個執行緒訊息就等於往佇列增加一個訊息，然後往socket寫一個位元組（任意內容）。即目標執行緒因為socket可讀而結束等待繼而執行訊息。
   綜上，用libevent來作為多執行緒間的事件迴圈和互發訊息是還有工作要做的。

5.HTTP client

evhttp有挺多的坑，如回撥的時機不明確、回撥的引數有可能為空，connection和request的生命週期奇異等。這些在文件中沒有過多的說明，只能吃一塹長一智。用C語言來寫的庫雖然效率高，但確實不怎麼好維護。
下面是自己的實驗程式碼，不想過多解釋，請自行參考。

// HttpTransaction.h

struct event_base;
struct evhttp_connection;
struct evhttp_request;
struct event;

class HttpTransaction {
 public:
  explicit HttpTransaction(event_base* base);
  ~HttpTransaction();

  class Delegate {
   public:
    virtual ~Delegate() {}

    virtual void OnResponseReceived(HttpTransaction* transaction,
        const HttpResponse& response) = 0;

    virtual void OnDataReceived(HttpTransaction* transaction,
        const char* data, size_t length) = 0;

    virtual void OnFinished(HttpTransaction* transaction) = 0;

    virtual void OnError(HttpTransaction* transaction, int error_code) = 0;
  };

  virtual void Start(int* out_error_code);

  virtual void Cancel();

  virtual HttpRequest* request() const { return http_request_; }
  virtual void set_request(HttpRequest* request) {
    http_request_ = request;
  }

  virtual Delegate* delegate() const { return delegate_; }
  virtual void set_delegate(Delegate* delegate) { delegate_ = delegate; }

  void OnEvRequestCallback(evhttp_request* req);
  void OnTimerCallback();

 private:
  enum State {
    STATE_NONE,
    STATE_WAITING_REQUEST_CALLBACK,
    STATE_REPORT_RESPONSE,
    STATE_REPORT_DATA,
    STATE_REPORT_FINISH,
    STATE_REPORT_ERROR
  };

  void SetupTimer();
  void DoReportResponse();
  void DoReportData();
  void DoReportFinish();
  void DoReportError();

  event_base* base_;
  HttpRequest* http_request_;
  Delegate* delegate_;
  evhttp_connection* ev_connection_;
  evhttp_request* ev_request_;
  event* call_delegate_timer_;
  State next_state_;
};

// HttpTransaction.cpp
#include <string.h>
#include <assert.h>
#include "event2/event.h"
#include "event2/http.h"
#include "event2/buffer.h"
#include "event2/keyvalq_struct.h"
#include "http_transaction_impl.h"
#include "http_request.h"
#include "mutable_http_response.h"

void RequestCallback(struct evhttp_request* req, void *arg) {
  HttpTransaction* transaction = static_cast<HttpTransaction*>(arg);
  transaction->OnEvRequestCallback(req);
}

void TimerCallback(evutil_socket_t fd, short what, void* arg) {
  HttpTransaction* transaction = static_cast<HttpTransaction*>(arg);
  transaction->OnTimerCallback();
}

HttpTransaction::HttpTransaction(struct event_base* base)
    : base_(base),
      http_request_(NULL),
      delegate_(NULL),
      ev_connection_(NULL),
      ev_request_(NULL),
      call_delegate_timer_(NULL),
      next_state_(STATE_NONE) {
}

HttpTransaction::~HttpTransaction() {
  Cancel();
}

void HttpTransaction::Start(int* out_error_code) {
  if (!delegate_) {
    *out_error_code = 1;
    return;
  }

  if (!http_request_) {
    *out_error_code = 4;
    return;
  }

  const char* url = http_request_->url();
  if (!url) {
    *out_error_code = 11;
    return;
  }
  struct evhttp_uri *uri = evhttp_uri_parse(url);
  if (!uri) {
    *out_error_code = 12;
    return;
  }

  const char* host = evhttp_uri_get_host(uri);
  if (!host) {
    evhttp_uri_free(uri);
    *out_error_code = 13;
    return;
  }
  int port = evhttp_uri_get_port(uri);
  if (port == -1)
    port = 80;

  const char* method = http_request_->method();
  if (!method) {
    evhttp_uri_free(uri);
    *out_error_code = 14;
    return;
  }
  evhttp_cmd_type cmd_type;
  if (strcmp(method, "GET") == 0) {
    cmd_type = EVHTTP_REQ_GET;
  } else if (strcmp(method, "POST") == 0) {
    cmd_type = EVHTTP_REQ_POST;
  } else {
    evhttp_uri_free(uri);
    *out_error_code = 15;
    return;
  }

  ev_connection_ = evhttp_connection_base_new(base_, NULL, host, port);
  if (!ev_connection_) {
    evhttp_uri_free(uri);
    *out_error_code = 2;
    return;
  }

  ev_request_ = evhttp_request_new(&RequestCallback, this);
  void* iter = NULL;
  const char* name = NULL;
  const char* value = NULL;
  struct evkeyvalq *headers = evhttp_request_get_output_headers(ev_request_);
  while (http_request_->EnumerateHeaderLines(&iter, &name, &value)) {
    evhttp_add_header(headers, name, value);
  }
  value = http_request_->GetHeader("host");
  if (!value) {
    evhttp_add_header(headers, "host", host);
  }

  const char* body = NULL;
  size_t length = 0;
  if (http_request_->body(&body, &length)) {
    struct evbuffer *buffer = evhttp_request_get_output_buffer(ev_request_);
    evbuffer_add(buffer, body, length);
  }

  // evhttp_make_request() may trigger RequestCallback() synchronously and the
  // return code is 0. An example is DNS error.
  int rv = evhttp_make_request(ev_connection_, ev_request_,
      cmd_type, evhttp_uri_get_path(uri));
  evhttp_uri_free(uri);
  if (rv == -1) {
    ev_request_ = NULL;
    evhttp_connection_free(ev_connection_);
    ev_connection_ = NULL;
    *out_error_code = 3;
    return;
  }

  if (next_state_ == STATE_NONE)
    next_state_ = STATE_WAITING_REQUEST_CALLBACK;
  *out_error_code = 0;
  // evhttp_connection_set_timeout(m_conn, (int)request.timeoutInterval());
}

void HttpTransaction::Cancel() {
  next_state_ = STATE_NONE;
  if (call_delegate_timer_) {
    event_del(call_delegate_timer_);
    event_free(call_delegate_timer_);
    call_delegate_timer_ = NULL;
  }
  if (ev_request_) {
    if (evhttp_request_is_owned(ev_request_))
      evhttp_request_free(ev_request_);
    ev_request_ = NULL;
  }
  if (ev_connection_) {
    evhttp_connection_free(ev_connection_);
    ev_connection_ = NULL;
  }
}

void HttpTransaction::OnEvRequestCallback(evhttp_request* req) {
  SetupTimer();
  if (req == NULL ||
      evhttp_request_get_response_code(ev_request_) == 0) {
    ev_request_ = NULL;
    next_state_ = STATE_REPORT_ERROR;
  } else {
    assert(ev_request_ == req);
    evhttp_request_own(req);
    next_state_ = STATE_REPORT_RESPONSE;
  }
}

void HttpTransaction::OnTimerCallback() {
  State state = next_state_;
  next_state_ = STATE_NONE;
  switch (state) {
  case STATE_REPORT_RESPONSE:
    DoReportResponse();
    break;
  case STATE_REPORT_DATA:
    DoReportData();
    break;
  case STATE_REPORT_FINISH:
    DoReportFinish();
    break;
  case STATE_REPORT_ERROR:
    DoReportError();
    break;
  default:
    assert(0);
    break;
  }
}

void HttpTransaction::SetupTimer() {
  if (!call_delegate_timer_) {
    call_delegate_timer_ = evtimer_new(base_, &TimerCallback, this);
  }
  struct timeval tv = { 0, 0 };
  event_add(call_delegate_timer_, &tv);
}

void HttpTransaction::DoReportResponse() {
  SetupTimer();
  next_state_ = STATE_REPORT_DATA;
  MutableHttpResponse* response =
      MutableHttpResponse::Create();
  const char* url = http_request_->url();
  response->set_url(url);
  response->set_status_code(evhttp_request_get_response_code(ev_request_));
  struct evkeyvalq* headers = evhttp_request_get_input_headers(ev_request_);
  for (struct evkeyval* header = headers->tqh_first; header;
    header = header->next.tqe_next) {
    response->AddHeader(header->key, header->value);
  }
  delegate_->OnResponseReceived(this, *response);
  delete response;
}

void HttpTransaction::DoReportData() {
  struct evbuffer *buf = evhttp_request_get_input_buffer(ev_request_);
  if (evbuffer_get_length(buf)) {
    const int kBufferSize = 1024 * 12;
    char* buffer = new char[kBufferSize];
    int n = evbuffer_remove(buf, buffer, kBufferSize);

    SetupTimer();
    if (evbuffer_get_length(buf))
      next_state_ = STATE_REPORT_DATA;
    else
      next_state_ = STATE_REPORT_FINISH;

    if (n > 0) {
      struct timeval tv = { 0, 0 };
      event_add(call_delegate_timer_, &tv);
      delegate_->OnDataReceived(this, buffer, n);
    }
    delete buffer;
  } else {
    DoReportFinish();
  }
}

void HttpTransaction::DoReportFinish() {
  Cancel();
  delegate_->OnFinished(this);
}

void HttpTransaction::DoReportError() {
  Cancel();
  delegate_->OnError(this, 0xdead);
}