Socket網絡編程--Libev庫學習(3)

　　這一小節繼續講解各個觀察器(Watcher).

　　上一小節已經講解了ev_io(IO可讀可寫觀察器)，ev_stat(文件屬性變化觀察器)，ev_signal(信號處理觀察器)，ev_timer(定時器)，ev_periodic(周期任務處理)，ev_child(子進程狀態變化觀察器)。這一小節准備講ev_fork(創建的進程時的觀察器)，ev_async(異步調用觀察器)，ev_cleanup(event loop退出時觸發事件)，ev_prepare(每次event loop之前事件),ev_check(每次event loop之后事件)，ev_idle(每次event loop空閑觸發事件).

　　ev_async  (ev_async當ev_async_send通過watcher調用時調用，觸發EV_ASYNC)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ev.h>

ev_async async_watcher;

static void sigint_callback(struct ev_loop *loop,ev_signal * w,int revents)
{
    if(revents & EV_SIGNAL)
    {
        printf("Call sigint_callback\n");
        printf("ev_async_send 調用前 %d\n",ev_async_pending(&async_watcher));
        ev_async_send(loop,&async_watcher);//這里會調用async_callback
        printf("ev_async_send 調用后 %d\n",ev_async_pending(&async_watcher));
    }
}

static void sigquit_callback(struct ev_loop *loop,ev_signal *w,int revetns)
{
    printf("Call sigquit_callback\n");
    ev_break(loop,EVBREAK_ALL);
}

static void async_callback(struct ev_loop *loop,ev_async *w,int revents)
{
    if(revents & EV_ASYNC)
    {
        printf("Call async_callback\n");
    }
}

int main(int argc, char **args)
{
    struct ev_loop *main_loop=ev_default_loop(0);

    ev_init(&async_watcher,async_callback);
    ev_async_start(main_loop,&async_watcher);

    ev_signal sigint_watcher;
    ev_init(&sigint_watcher,sigint_callback);
    ev_signal_set(&sigint_watcher,SIGINT);
    ev_signal_start(main_loop,&sigint_watcher);

    ev_signal sigquit_watcher;//這里的ev_signal不能與上面共用,必須在聲明一個變量
    ev_init(&sigquit_watcher,sigquit_callback);
    ev_signal_set(&sigquit_watcher,SIGQUIT);
    ev_signal_start(main_loop,&sigquit_watcher);

    ev_run(main_loop,0);
    return 0;
}

　　下面這個是運行截圖

　　可以看出程序ev_async這個是通過ev_async_send來驅動async_callback這個回調函數執行的。而且ev_async_pending這個也是可以判斷ev_async是否處於pending狀態。我在第15行處增加了sleep(1)后，運行的結構還是一樣，可以看出ev_async所綁定的回調函數是處於pending狀態而不是另外開一個線程(進程)來執行的。

　　從上面的處理機制看，好像就是發送一個信號，然后ev_async就調用回調函數去執行，好像跟ev_signal一樣，沒有什么特點啊。這里給出官方文檔的解釋。

This functionality is very similar to ev_signal watchers, as signals, too, are asynchronous in nature, and signals, too, will be compressed (i.e. the number of callback invocations may be less than the number of ev_async_sent calls).

Unlike ev_signal watchers, ev_async works with any event loop, not just the default loop.

　　上面說到，不同與ev_signal watchers的是，ev_async可以在多種event loop，而不是默認的loop。前幾小節已經講到ev_loop 的創建，可以通過ev_loop_new進行創建(創建異步事件什么的)。具體的用法這里還不是很清楚，先跳過。

　　ev_fork (開辟進程時觀察器)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ev.h>

static void fork_callback(struct ev_loop *loop,ev_fork *w,int revents)
{
    printf("Call fork_callback\n");
}

static void timeout_callback(struct ev_loop*loop,ev_timer *w,int revents)
{
    printf("Time Out\n");
    ev_break(loop,EVBREAK_ALL);
}

int main(int argc, char **args)
{
    struct ev_loop *main_loop=ev_default_loop(0);

    ev_fork fork_watcher;
    ev_init(&fork_watcher,fork_callback);
    ev_fork_start(main_loop,&fork_watcher);

    ev_timer timer_watcher;
    ev_init(&timer_watcher,timeout_callback);
    ev_timer_set(&timer_watcher,3,0);
    ev_timer_start(main_loop,&timer_watcher);

    switch(fork())
    {
        case -1:
            break;
        case 0://child
            //ev_loop_fork(main_loop);
            break;
    }

    ev_run(main_loop,0);
    return 0;
}

　　上面這個代碼沒有輸出Call fork_callback，如果把第36行的注釋去掉，就會輸出Call fork_callback了，可以說明這個ev_fork不是針對fork函數創建的進程。而是要ev_loop_fork針對ev_loop 創建的loop。具體解釋的不是很清楚，下面給出官方文檔:

Fork watchers are called when a fork () was detected (usually because whoever is a good citizen cared to tell libev about it by calling ev_default_fork or ev_loop_fork). The invocation is done before the event loop blocks next and before ev_check watchers are being called, and only in the child after the fork. If whoever good citizen calling ev_default_fork cheats and calls it in the wrong process, the fork handlers will be invoked, too, of course.

　　loop的創建小解

struct　ev_loop　*ev_default_loop　(unsigned　int　flags)　
struct　ev_loop　*ev_loop_new　(unsigned　int　flags)　
//這兩個函數都是默認原始化一個loop，區別是第一個不是線程安全的，第二個不能捕捉信號和子進程的watcher。 
//參數flags可以為下面幾種類型： 
//引用
#define EVFLAG_AUTO        0x00000000U /* not quite a mask */ 
/* flag bits */ 
#define EVFLAG_NOENV       0x01000000U /* do NOT consult environment */ 
#define EVFLAG_FORKCHECK   0x02000000U /* check for a fork in each iteration */ 
/* method bits to be ored together */ 
#define EVBACKEND_SELECT   0x00000001U /* about anywhere */ 
#define EVBACKEND_POLL     0x00000002U /* !win */ 
#define EVBACKEND_EPOLL    0x00000004U /* linux */ 
#define EVBACKEND_KQUEUE   0x00000008U /* bsd */ 
#define EVBACKEND_DEVPOLL  0x00000010U /* solaris 8 */ /* NYI */ 
#define EVBACKEND_PORT     0x00000020U /* solaris 10 */
ev_default_fork　()　
ev_loop_fork　(loop)
//這兩個函數就是當你在子進程里須要 運用 libev的函數的之前必須要調用。他們的區別是第二個函數是當運用 ev_loop_new建立 的loop時，才用第二個函數,也就是說重用父進程建立 的loop。 
ev_loop (loop,　int　flags)
//開始事件循環。 
ev_TYPE_init (ev_TYPE　*watcher,　callback,　[args]) 
//原始化一個watcher。TYPE也就是libev支持的事件類型，比如io，比如time等等。。 
//第一個參數為一個watcher,第二個回調函數，第三個句柄，第四個事件類型。包含下面幾種： 
//引用
#define EV_UNDEF     -1 /* guaranteed to be invalid */ 
#define EV_NONE      0x00 /* no events */ 
#define EV_READ      0x01 /* ev_io detected read will not block */ 
#define EV_WRITE     0x02 /* ev_io detected write will not block */ 
#define EV_IOFDSET   0x80 /* internal use only */ 
#define EV_TIMEOUT   0x00000100 /* timer timed out */ 
#define EV_PERIODIC  0x00000200 /* periodic timer timed out */ 
#define EV_SIGNAL    0x00000400 /* signal was received */ 
#define EV_CHILD     0x00000800 /* child/pid had status change */ 
#define EV_STAT      0x00001000 /* stat data changed */ 
#define EV_IDLE      0x00002000 /* event loop is idling */ 
#define EV_PREPARE   0x00004000 /* event loop about to poll */ 
#define EV_CHECK     0x00008000 /* event loop finished poll */ 
#define EV_EMBED     0x00010000 /* embedded event loop needs sweep */ 
#define EV_FORK      0x00020000 /* event loop resumed in child */ 
#define EV_ASYNC     0x00040000 /* async intra-loop signal */ 
#define EV_ERROR     0x80000000 /* sent when an error occurs */ 
//引用
ev_TYPE_start (loop *, ev_TYPE *watcher)
//啟動一個watcher。 

 

    switch(fork())
    {
        case -1:
            break;
        case 0://child
            ev_loop_fork(main_loop);//使用父進程main_loop
            ev_timer timer_watcher1;
            ev_init(&timer_watcher1,timeout_callback);
            ev_timer_set(&timer_watcher1,3,0);
            ev_timer_start(main_loop,&timer_watcher1);
            break;
    }

　　上面代碼如果修改如下是可以編譯通過的。就是在父進程中的main_loop中再增加一個watcher，這個程序將會輸出三次Time Out。注意如果沒有第六行的ev_loop_fork是編譯不通過的。大概的原因是ev庫設計的原因。

　　下面給出一個例子，用於以后可以參考用

#include <ev.h>
#include <stdio.h>

//不同的watcher
ev_io stdin_watcher;
ev_timer timeout_watcher;
ev_timer timeout_watcher_child;

//標准輸入的回調函數
static void stdin_cb (EV_P_ ev_io *w, int revents)
{
    puts ("stdin ready");
    ev_io_stop (EV_A_ w);
    ev_unloop (EV_A_ EVUNLOOP_ALL);
}

//父進程的定時器回調函數
static void timeout_cb (EV_P_ ev_timer *w, int revents)
{
    puts ("timeout");
    ev_unloop (EV_A_ EVUNLOOP_ONE);
}
//子進程的定時器回調函數
static void timeout_cb_child (EV_P_ ev_timer *w, int revents)
{
    puts ("child timeout");
    ev_unloop (EV_A_ EVUNLOOP_ONE);
}

static void fork_callback(struct ev_loop *loop,ev_fork *w,int revents)
{
    printf("Call fork_callback\n");
}

int main (void)
{
    //創建一個backend為select的loop
    struct ev_loop *loop = ev_loop_new(EVBACKEND_SELECT);

    //初始化並啟動父進程的watcher
    ev_timer_init(&timeout_watcher, timeout_cb, 10, 0.);
    ev_timer_start(loop, &timeout_watcher);
    switch (fork()) {
        case -1:
            return -1;
        case 0:
            //使用父進程loop。
            ev_loop_fork(loop);
            //子進程的loop
            struct ev_loop *loop_child = ev_loop_new (EVBACKEND_SELECT);
            ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
            ev_io_start (loop, &stdin_watcher);
            ev_timer_init(&timeout_watcher_child, timeout_cb_child, 5.5, 0.);
            ev_timer_start(loop_child, &timeout_watcher_child);
            ev_loop(loop_child,0);
    }

    //等待事件
    ev_loop (loop, 0);
    return 0;
}

　　ev_cleanup  event loop 退出觸發事件

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ev.h>

struct ev_loop *main_loop;

static void program_exits(void)
{
    printf("Call AtExit\n");
    ev_loop_destroy(EV_DEFAULT);//注釋掉43行處代碼，該函數在這里沒有調用到cleanup_callback，但是卻執行沒有錯誤
}

static void cleanup_callback(struct ev_loop *loop,ev_cleanup *w,int revents)
{
    printf("Call cleanup_callback\n");
}

static void timer_callback(struct ev_loop *loop,ev_timer *w,int revents)
{
    printf("Call timer_callback\n");
}

int main(int argc, char **args)
{
    //struct ev_loop *main_loop=ev_default_loop(0);//error 注意ev_loop_destroy與ev_loop_new對應
    main_loop=ev_loop_new(EVBACKEND_EPOLL);

    ev_cleanup cleanup_watcher;
    ev_init(&cleanup_watcher,cleanup_callback);
    ev_cleanup_start(main_loop,&cleanup_watcher);

    ev_timer timer_watcher;
    ev_init(&timer_watcher,timer_callback);
    ev_timer_set(&timer_watcher,0.2,0);
    ev_timer_start(main_loop,&timer_watcher);

    atexit(program_exits);

    ev_run(main_loop,0);

    ev_loop_destroy(main_loop);//在這里就可以調用到cleanup_callback
    printf("END\n");
    return 0;
}

　　運行時截圖

　　ev_prepare  (每次event loop之前事件)

　　ev_check  (每次event loop之后事件)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ev.h>

static void prepare_callback(struct ev_loop *loop,ev_prepare *w,int revents)
{
    printf("Prepare Callback\n");
}

static void check_callback(struct ev_loop *loop,ev_check *w,int revents)
{
    printf("Check Callback\n");
}

static void timer_callback(struct ev_loop *loop,ev_timer *w,int revents)
{
    printf("Timer Callback\n");
}

static void sigint_callback(struct ev_loop *loop,ev_signal *w,int revents)
{
    printf("Sigint Callback\n");
    ev_break(loop,EVBREAK_ALL);
}

int main(int argc, char **args)
{
    struct ev_loop *main_loop=ev_default_loop(0);

    ev_prepare prepare_watcher;
    ev_check check_watcher;
    ev_timer timer_watcher;
    ev_signal signal_watcher;

    ev_prepare_init(&prepare_watcher,prepare_callback);
    ev_check_init(&check_watcher,check_callback);
    ev_timer_init(&timer_watcher,timer_callback,2,0);
    ev_signal_init(&signal_watcher,sigint_callback,SIGINT);

    ev_prepare_start(main_loop,&prepare_watcher);
    ev_check_start(main_loop,&check_watcher);
    ev_timer_start(main_loop,&timer_watcher);
    ev_signal_start(main_loop,&signal_watcher);

    ev_run(main_loop,0);
    return 0;
}

　　運行結果

　　看前三個為一組，我測試了幾次都是這樣，Timer Callback的輸出都是在Check之后，這個不知道為什么不過后面的捕獲SIGINT信號就沒有這個問題，SIGINT信號的回調函數的輸出是處於Prepare和Check之間。這個就符合預想。還有就是我們輸入一個Ctrl-C時，也會觸發Prepare-Check的回調函數。這個倒是沒有想到，應該是一個ev_signal會向ev_loop里放入兩個處理過程，一個是Linux默認的捕獲SIGINT信號(signal函數)一個是我們的回調函數，大概是在默認的回調函數中調用我們的回調函數，畢竟捕獲信號是系統調用。上面這個是我的猜想(理解)，不一定是正確的。

　　ev_idle (每次event loop空閑觸發事件)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ev.h>

ev_idle idle_watcher;
int count=0;

static void timer_callback_start(struct ev_loop *loop,ev_timer *w,int revents)
{
    printf("Timer Callback Start\n");
    ev_idle_start(loop,&idle_watcher);
}
static void timer_callback_stop(struct ev_loop *loop,ev_timer *w,int revents)
{
    printf("Timer Callback Stop\n");
    ev_idle_stop(loop,&idle_watcher);
}

static void sigint_callback(struct ev_loop *loop,ev_signal *w,int revents)
{
    printf("Sigint Callback\n");
    ev_break(loop,EVBREAK_ALL);
}

static void idle_callback(struct ev_loop *loop,ev_idle *w,int revents)
{
    count++;
}

int main(int argc, char **args)
{
    struct ev_loop *main_loop=ev_default_loop(0);

    ev_timer timer_watcher_start;
    ev_timer timer_watcher_stop;
    ev_signal signal_watcher;

    ev_idle_init(&idle_watcher,idle_callback);
    ev_timer_init(&timer_watcher_start,timer_callback_start,1,0);
    ev_timer_init(&timer_watcher_stop,timer_callback_stop,3,0);
    ev_signal_init(&signal_watcher,sigint_callback,SIGINT);

    ev_timer_start(main_loop,&timer_watcher_start);
    ev_timer_start(main_loop,&timer_watcher_stop);
    ev_signal_start(main_loop,&signal_watcher);

    ev_run(main_loop,0);

    printf("從第1秒到第3秒之間count計數器的累加到 %d\n",count);
    return 0;
}

　　運行結果

　　我們的idle是可以控制開始和結束的。而這個idle的作用是但event_loop處於空閑的時候，與其在ev_run阻塞等待，不如利用這時的cpu時間來做其他事。應用的話，就是如果服務器繁忙的話就主要處理請求等，如果服務器請求不多時，可以利用cpu時間來處理備份什么的，這樣就可以最大限度的利用cpu了。

　　觀察器watcher差不多就這些了，還有個ev_embed這個還不會用。

 

　　參考資料: http://wangjunle23.blog.163.com/blog/static/11783817120124308920321/

　　　　　   : http://simohayha.iteye.com/blog/306712

　　本文地址: http://www.cnblogs.com/wunaozai/p/3955156.html