1. 一個新的 Connection 進來，用 fork() 產生一個 Process 處理。
2. 一個新的 Connection 進來，用 pthread_create() 產生一個 Thread 處理。
3. 一個新的 Connection 進來，丟入 Event-based Array，由 Main Process 以 Nonblocking 的方式處理所有的 I/O。
   

1. 用 fork() 的問題在於每一個 Connection 進來時的成本太高。
2. 用 Multi-thread 的問題在於 Thread-safe 與 Deadlock 問題難以解決，另外有 Memory-leak 的問題要處理。
3. 用 Event-based 的方式在於實做上不好寫，尤其是要注意到事件產生時必須 Nonblocking，於是會需要實做 Buffering 的問題，而 Multi-thread 所會遇到的 Memory-leak 問題在這邊會更嚴重。而在多 CPU 的系統上沒有辦法使用到所有的 CPU resource。
   

1. 以 Poll 的方式解決：當一個 Process 處理完一個 Connection 後，不直接死掉，而繼續回到 accept() 的狀態繼續處理，但這樣會遇到 Memory-leak 的問題，於是採用這種方式的人通常會再加上「處理過 N 個 Connection 後死掉，由 Parent Process 再 fork() 一隻新的」。最有名的例子是 Apache 1.3。
2. Thread-safe 的問題可以透過自己撰寫，或是尋找其他 Thread-safe Library 直接使用。Memory-leak 的問題可以試著透過 Garbage Collection Library 分析出來。Apache 2.0 的 Thread MPM 就是使用這個模式。
   

1. select() 與 poll() 的效率過慢，造成每次要判斷「有哪些 Event 發生」這件事情的成本很高，這在 BSD 支援 kqueue()、Linux 支援 epoll()、Solaris 支援 /dev/poll 後就解決了，但這兩組 Function 都不是 Standard，於是在不同的平台上就必須再改一次。
   
2. 因為 Nonblocking，所以在 write() 或是 send() 時滿了需要自己 Buffering。
3. 因為 Nonblocking，所以不能使用 fgets() 或是其他類似的 function，於是需要自己刻一個 Nonblocking 的 fgets()。但是使用者所丟過來的資料又不能保證在一次 read() 或 recv() 就有一行，於是要自己做 Buffering。

#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <event.h>
#include <stdio.h>
#include <time.h>

void connection_time(int fd, short event, struct event *arg)
{
    char buf[32];
    struct tm t;
    time_t now;

    time(&now);
    localtime_r(&now, &t);
    asctime_r(&t, buf);

    write(fd, buf, strlen(buf));
    shutdown(fd, SHUT_RDWR);

    free(arg);
}

void connection_accept(int fd, short event, void *arg)
{
    /* for debugging */
    fprintf(stderr, "%s(): fd = %d, event = %d.\n", __func__, fd, event);

    /* Accept a new connection. */
    struct sockaddr_in s_in;
    socklen_t len = sizeof(s_in);
    int ns = accept(fd, (struct sockaddr *) &s_in, &len);
    if (ns < 0) {
        perror("accept");
        return;
    }

    /* Install time server. */
    struct event *ev = malloc(sizeof(struct event));
    event_set(ev, ns, EV_WRITE, (void *) connection_time, ev);
    event_add(ev, NULL);
}

int main(void)
{
    /* Request socket. */
    int s = socket(PF_INET, SOCK_STREAM, 0);
    if (s < 0) {
        perror("socket");
        exit(1);
    }

    /* bind() */
    struct sockaddr_in s_in;
    bzero(&s_in, sizeof(s_in));
    s_in.sin_family = AF_INET;
    s_in.sin_port = htons(7000);
    s_in.sin_addr.s_addr = INADDR_ANY;
    if (bind(s, (struct sockaddr *) &s_in, sizeof(s_in)) < 0) {
        perror("bind");
        exit(1);
    }

    /* listen() */
    if (listen(s, 5) < 0) {
        perror("listen");
        exit(1);
    }

    /* Initial libevent. */
    event_init();

    /* Create event. */
    struct event ev;
    event_set(&ev, s, EV_READ | EV_PERSIST, connection_accept, &ev);

    /* Add event. */
    event_add(&ev, NULL);

    event_dispatch();

    return 0;
}

#include <sys/time.h>
#include <event.h>
#include <stdio.h>

void printbuf(struct evbuffer *evbuf)
{
    for (;;) {
        char *buf = evbuffer_readline(evbuf);
        printf("* buf = %p, the string = \"\e[1;33m%s\e[m\"\n", buf, buf);
        if (buf == NULL)
            break;
        free(buf);
    }
}

int main(void)
{
    struct evbuffer *evbuf;

    evbuf = evbuffer_new();
    if (evbuf == NULL) {
        fprintf(stderr, "%s(): evbuffer_new() failed.\n", __func__);
        exit(1);
    }

    /* Add "gslin" into buffer. */
    u_char *buf1 = "gslin";
    printf("* Add \"\e[1;33m%s\e[m\".\n", buf1);
    evbuffer_add(evbuf, buf1, strlen(buf1));
    printbuf(evbuf);

    u_char *buf2 = " is reading.\nAnd he is at home.\nLast.";
    printf("* Add \"\e[1;33m%s\e[m\".\n", buf2);
    evbuffer_add(evbuf, buf2, strlen(buf2));
    printbuf(evbuf);

    evbuffer_free(evbuf);
}

Author : Kevin Lynx

前言

    可以说对于任何网络库(模块)而言，一个缓冲模块都是必不可少的。缓冲模块主要用于缓冲从网络接收到的数据，以及
用户提交的数据(用于发送)。很多时候，我们还需要将网络模块层(非TCP层)的这些缓冲数据拷贝到用户层，而这些内存拷贝
都会消耗时间。
    在这里，我简要分析下libevent的相关代码(event.h和buffer.c)。

结构

    关于libevent的缓冲模块，主要就是围绕evbuffer结构体展开。先看下evbuffer的定义：

/**//*event.h*/
struct evbuffer {
    u_char *buffer;
    u_char *orig_buffer; 

    size_t misalign;
    size_t totallen;
    size_t off; 

    void (*cb)(struct evbuffer *, size_t, size_t, void *);
    void *cbarg;
};

    libevent的缓冲是一个连续的内存区域，其处理数据的方式(写数据和读数据)更像一个队列操作方式：从后写入，从前
读出。evbuffer分别设置相关指针(一个指标)用于指示读出位置和写入位置。其大致结构如图：

    orig_buffer指向由realloc分配的连续内存区域，buffer指向有效数据的内存区域，totallen表示orig_buffer指向的内存
区域的大小，misalign表示buffer相对于orig_buffer的偏移，off表示有效数据的长度。

实际运作

    这里我将结合具体的代码分析libevent是如何操作上面那个队列式的evbuffer的，先看一些辅助函数：

evbuffer_drain:
    该函数主要操作一些指标，当每次从evbuffer里读取数据时，libevent便会将buffer指针后移，同时增大misalign，减小off，
而该函数正是做这件事的。说白了，该函数就是用于调整缓冲队列的前向指标。

evbuffer_expand:
    该函数用于扩充evbuffer的容量。每次向evbuffer写数据时，都是将数据写到buffer+off后，buffer到buffer+off之间已被
使用，保存的是有效数据，而orig_buffer和buffer之间则是因为读取数据移动指标而形成的无效区域。
    evbuffer_expand的扩充策略在于，首先判断如果让出orig_buffer和buffer之间的空闲区域是否可以容纳添加的数据，如果
可以，则移动buffer和buffer+off之间的数据到orig_buffer和orig_buffer+off之间(有可能发生内存重叠，所以这里移动调用的
是memmove)，然后把新的数据拷贝到orig_buffer+off之后；如果不可以容纳，那么重新分配更大的空间(realloc)，同样会移动
数据。
    扩充内存的策略为：确保新的内存区域最小尺寸为256，且以乘以2的方式逐步扩大(256、512、1024、...)。

    了解了以上两个函数，看其他函数就比较简单了。可以看看具体的读数据和写数据：

evbuffer_add:
    该函数用于添加一段用户数据到evbuffer中。很简单，就是先判断是否有足够的空闲内存，如果没有则调用evbuffer_expand
扩充之，然后直接memcpy，更新off指标。

evbuffer_remove:
    该函数用于将evbuffer中的数据复制给用户空间(读数据)。简单地将数据memcpy，然后调用evbuffer_drain移动相关指标。

其他

    回过头看看libevent的evbuffer其实是非常简单的(跟我那个kl_net里的buffer一样)，不知道其他人有没有更优的缓冲管理
方案。evbuffer还提供了两个函数：evbuffer_write和evbuffer_read，用于直接在套接字(其他文件描述符)上写/读数据。

    另外，关于libevent，因为官方提供的VC工程文件有问题，很多人在windows下编译不过。金庆曾提供过一种方法。其实主要
就是修改event-config.h文件，修改编译相关配置。这里我也提供一个解决步骤，顺便提供完整包下载：

1. vs2005打开libevent.dsw，转换四个工程(event_test, libevent, signal_test, time_test)
2. 删除libevent项目中所有的文件，重新添加文件，文件列表如下：
   buffer.c
   evbuffer.c
   evdns.c
   evdns.h
   event.c
   event.h
   event_tagging.c
   event-config.h
   event-internal.h
   evhttp.h
   evrpc.h
   evrpc.c
   evrpc-internal.h
   evsignal.h
   evutil.c
   evutil.h
   http.c
   http-internal.h
   log.c
   log.h
   min_heap.h
   strlcpy.c
   strlcpy-internal.h
   tree.h
   win32.c
   config.h
   signal.c
3. 替换event-config.h，使用libevent-iocp中的
4. 项目设置里添加HAVE_CONFIG_H预处理宏
5. 修改win32.c中win32_init函数，加入WSAStartup函数，类似于：
       WSADATA wd;   
        int err;
        struct win32op *winop;
        size_t size;
        if( ( err = WSAStartup( MAKEWORD( 2, 2 ), &wd ) ) != 0 )
            event_err( 1, "winsock startup failed : %d", err );
6. 修改win32.c中win32_dealloc函数，在函数末尾加上WSACleanup的调用：
        WSACleanup();
6. 至此libevent编译成功；
7. 几个例子程序，只需要加入HAVE_CONFIG_H预处理宏，以及连接ws2_32.lib即可；
   (time_test需要修改time-test.c文件，即在包含event.h前包含windows.h)

     tail queue的操作相关宏：
     TAILQ_HEAD(HEADNAME, TYPE) head --->定义串连TYPE类型的结构，同时将这种"新"类型的tail queue结构命名为HEADNAME, 最后还定义了一个变量“head”。
     TAILQ_INIT(&head) --->初始化tail queue的两个指针，对列的头指针和队列的尾指针
    
     TAILQ_ENTRY (TYPE) --->这个宏使用在TYPE结构体的定义内部，它定义维护结构体对象在tail queue中的位置所需要的指针。
    
     TAILQ_INSERT_HEAD/TAILQ_INSERT_TAIL/TAILQ_INSERT_AFTER/TAILQ_REMOVE,这些宏的作用比较明显，需要注意的是它们都需要传入head指针和TAILQ_ENTRY定义的标识符。
     (我觉得宏最强的地方和最有问题的地方就是它不进行类型检查，最让代码阅读者头痛的就是条件编译^_^)。
   
    2、reb black tree
   
      red black tree（rbt） 是一种近似的二叉平衡树,它的特点如下：
      1、根节点是黑色的
      2、表示rbt节点结构的空指针都会指向一个空的节点（rchild, lchild, lparent）,而且空节点是黑色的
      3、红色节点的rchild/lchild/parent都是红色节点
      4、从根节点到空节点的任一路径所包含的黑色节点数是相同的
     
      rbt很重要的一个操作就是子树旋转，它是调整rbt结构的辅助操作。例如：右旋转:
         |                                    |             
        A                                    B           这里需要注意的是旋转前B的右子节点y变成
       /   \                                /  \         了A的左子节点
      B    C   =======>      x    A
     /  \                                       /  \
    x    y                                    y    C
   
      rbt的插入算法：
      按照二叉排序树的流程插入一个新的元素
      并把该节点设置为红色
                   |
        调整新的"树"，使它满足rbt的条件
                   |
            如果新节点的父节点为黑色，那么
            调整完成
                   |
     如果父节点的颜色为红色，那么进行以下的操作：
     假设：cn为当前节点
           pn 为当前节点的父节点
           pun 为当前节点的父节点的兄弟节点
           cn 是pn的左子节点。
     1、如果pun是红色，那么将pn和pun都变成黑色，同时把cn设为pn->lparent,重新进入迭代
     2、如果pun是黑色，而且cn是pn的右子节点，那么将cn = pn,然后做一次左旋转LR(cn)操作，这样就
       可以把调整的树转换到左子树上，这样就把树的结构转换到第三种情况。
     3、如果pun是黑色，而且cn是pn的左子节点，那么将pn设置为黑色，并把pn->lparent设置为红色，
        同时进行右旋转RR(pn->lparent)-->这时整个调整流程结束。
       
      rbt的删除算法：
      按照二叉排序树的删除流程删除一个元素
    如果删除的节点是红色的，那么它不会破坏rbt的条件，如果删除的节点是黑色的，那么就需要对新的树进行调整，使它满足tbt的条件
      设rn 为替代被删除节点的节点（由于所有"逻辑上悬空"的指针都会指向"特殊的空节点"，所以比如存在替代被删除节点的替代节点），且它是rn->lparent的左子节点（对于右子节点的情况处理方式是对称的）
        rcn 为rn的兄弟节点
                  |
       如果cn是红色，那么只要把它变成黑色就满足rbt条件
       如果cn是黑色，那么就要根据rcn的颜色分别进行处理：
         1、rcn是红色，那么可以知道cn->lparent是黑色，rcn的两个子节点都是黑色，那么把cn->lparent和w的颜色
              互换，并进行左旋转操作LR（x->parent）,这样cn就会有一个新的兄弟节点，而且它是黑色的。
         2、rcn是黑色，而且rcn的两个子节点都是黑色，这样只要把rcn设为红色，并把当前节点变成它的父节点               cn = cn->lparent 进行递规迭代就可以了
         3、rcn是黑色，而且左子节点rcn->lleft是红色，右子节点rcn->lright是黑色, 那么把rcn和rcn->lleft的颜色
               互换，并进行右旋转操作RR(rcn)，这样就会转换到第四中情况，而且cn也有了一个新的兄弟节点
         4、rcn是黑色，而且rcn的右子节点是红色，那么将rcn与rcn->parent的颜色互换，并进行左旋转操作

             LR(rcn->lparent),
             这样就把缺少的黑色节点转移的原来的rcn->lright节点上，而且这个节点是红色的，这时只要把它的颜色转变成黑色就能完成rbt条件的修补。
     
      现在我们对于红黑树的一些算法都比较清楚了，下面看看与红黑树操作相关的几个宏的使用
      RB_HEAD(my_rb_tree, rb_entry) rb_head;
     
      struct my_rb_tree * rb_tree;
     
      struct rb_entry {
        ...
        RB_ENTRY(rb_entry) rb_entry_list;
        ...
      };
     
      rb_tree = malloc(sizeof(struct my_rb_tree))
      RB_INIT(rb_tree);
      ...
     
      struct rb_entry * prb1 = NULL, *prb2 = NULL;
      ...
     
      RB_INSERT(my_rb_tree, rb_tree, prb1 = malloc(sizeof(struct rb_entry)))
      RB_INSERT(my_rb_tree, rb_tree, prb2 = malloc(sizeof(struct rb_entry)))
      ...
     
      struct rb_entry * min = RB_MIN(my_rb_tree, rb_tree);
      struct rb_entry * max = RB_MAX(my_rb_tree, rb_tree);
      assert(RB_EMPTY(rb_tree))
      ...
      RB_FOREACH(tmp_entry, my_rb_tree, rb_tree)
  custom_function(temp_entry);
  
   struct rb_entry * t_entry = NULL;
   RB_NEXT(my_rb_tree, rb_tree, t_entry);
   ...
   RB_REMOVE(my_rb_tree, rb_tree, prb1);
   ...
   RB_FIND(my_rb_tree, rb_tree, prb2）
  
   上面的这些操作都比较简单，参数的含义也比较明显，这里就不多说了。
  
   需要注意的是rbt定义的辅助宏：
   RB_PROTOTYPE(my_rb_tree, rb_entry, rb_entry_list, compare)：声明一些操作函数，它的参数的含义是：
          my_rb_tree: 用户定义的rbt的名称, 它可用于后面的变量定义
          rb_entry:   rbt中保存的结构体类型
          rb_entry_list: rb_tree定义中RB_ENTRY定义的字段成员字段的名称
          compare :   比较函数，用于在find算法和remove算法中查找目标元素，它的原型是：int compare(struct rb_entry * a, struct rb_entry* b)
   RB_GENERATE(my_rb_tree, rb_entry, rb_entry_list, compare)：产生操作函数的代码, 它的参数的含义和RB_PROTOTYPE的含义是一样的。

class Switch
{
public:
     virtual void Clicked() = 0;
};
class Light
{
public:
     void ToggleState();
     void TurnOn();
     void TurnOff();
};
class ToggleSwitch : public Switch
{
public:
     ToggleSwitch(Light& lp){m_lp = lp;}
     virtual void Clicked(){m_lp.ToggleState();}
private:
     Light& m_lp;
};
Light lp1, lp2;
ToggleSwitch tsw1(lp1), tsw2(lp2);

这在功能上完全可以实现，但想象一下如果大量的需要相互交互消息的类，那工作量就不是一般的大了。
使用sig/slot机制来解决上述情况，不需要关心关联类的接口细节，sigslot实现的switch和light上述功能如下：

class Switch
{
public:
     signal0<> Clicked;
};
class Light : public has_slots<>
{
public:
     void ToggleState();
     void TurnOn();
     void TurnOff();
};
Switch sw1, sw2;
Light lp1, lp2;

    
     Sigslot机制实现该功能与第一种方法相比，switch类多了个signal0成员，light类需要从has_slots<>继承，其他没有什么变化，但省去了编写继承类用来实现两者关联的ToggleSwitch。
下面是实现功能的简单代码。
  

#include <iostream>
using namespace std;
 
#include "sigslot.h"
using namespace sigslot; //必须加上sigslot的命名空间
//在用vs调试时还需要将sigslot.h中很多的自定义模板结构类型前加typename
const int TRUE = 1;
const int FALSE = 0;
class Switch
{
public:
       signal0<> Clicked;
//这里的信号是不带参数的，signaln表示带几个参数
};
class Light : public has_slots<>
{
public:
       Light(bool state){b_state = state;Displaystate();}
       void ToggleState(){b_state = !b_state;Displaystate();} //作为消息的响应
       void TurnOn(){b_state = TRUE;Displaystate();}
       void TurnOff(){b_state = FALSE;Displaystate();}
       void Displaystate(){cout<<"The state is "<<b_state<<endl;}
private:
       bool b_state;
};
void main()
{
       Switch sw1, sw2,all_on,all_off;
       Light lp1(TRUE), lp2(FALSE);
       sw1.Clicked.connect(&lp1,&Light::ToggleState); //绑定
       sw2.Clicked.connect(&lp2,&Light::ToggleState);
       all_on.Clicked.connect(&lp1,&Light::TurnOn);
       all_on.Clicked.connect(&lp2,&Light::TurnOn);
       all_off.Clicked.connect(&lp1,&Light::TurnOff);
       all_off.Clicked.connect(&lp2,&Light::TurnOff);
 
       sw1.Clicked();
       sw2.Clicked();
       all_on.Clicked();
       all_off.Clicked();
 
       sw1.Clicked.disconnect(&lp1);
       sw2.Clicked.disconnect(&lp2);
       all_on.Clicked.disconnect(&lp1);
       all_on.Clicked.disconnect(&lp2);
       all_off.Clicked.disconnect(&lp1);
       all_off.Clicked.disconnect(&lp2);
}
 

 
3  。  参数类型
        sig/slot可以带参数也可以不带，最多可以带8个参数。重新回顾上例，switch类的signal0<> Clicked,称之为sig，即用来发出信号；而继承has_slots<>的类light的成员函数void ToggleState() Turnon() Turnoff(),称之为slot,即信号的处理函数。 sigslot的核心就在这里，就是通过这两个建立对应关系来实现对象间的消息交互。
sig是一个成员变量，它形如
 
signal+n<type1,type2……>
    后面的n表示signal可以接收几个参数，类型任意，最多为8个。这是由库中指定的，当然如果实际开发需要更多的参数，可以修改sigslot库。
slot是一个成员函数，它形如：
void SlotFunction(type1,type2……)
   需要记住：slot的类必须继承has_slots<>;成员函数的返回值必须为void类型，这是这个库的局限性，当然如果实际开发需要返回值，也是可以修改sigslot库来实现。此外还需要注意的是slot的原形需要与sig一致。怎么说呢，就是signal只能与带有与它相同参数个数的slot函数进行绑定，而且signal的参数是直接传递给slot的。
 
4.    Sigslot库用法
发送信号
信号(sig，即sig/slot的sig，下面提到的信号等同于此含义)：
signal1<char *, int> ReportError;
比如上面的一个ReportError这个信号，当调用ReportError("Something went wrong", ERR_SOMETHING_WRONG);时候，将自动调用ReportError的emit成员函数发出一个信号。发给谁呢？
 
连接信息号
通过调用sig的connect函数建立sig和slot间的对应关系。Connect函数接收两个参数，一个是消息目的对象的地址(指针)，另一个是目的对象的成员函数指针(slot)。为了让整个机制有效运行，目的类必须从has_slots<>继承，并且sig/slot参数类型必须一致。也可以将一个sig连接到多个slot上，这样每次sig发出信号的时候，每个连接的slot都能收到该信号。
 
断开信号连接
通过调用sig的disconnect函数断开sig和slot之间的连接，只有一个参数：目的对象的地址。一般不需要显式调用disconnect函数，在sig类和目的类(包含slot函数的类)析构函数中将自动调用disconnect断开sig和slot的连接。也可使用disconnect_all断开该sig的所有slot。
all_on.Clicked.connect(&lp1,&Light::TurnOn);
all_on.Clicked.connect(&lp2,&Light::TurnOn);//同上
all_on.Clicked.disconnect_all();

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/smallcraft/archive/2008/04/01/2237802.aspx