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

　　這一小節講各個觀察器(Watcher)

　　在libev下面watcher相當於EventHandler這么一個概念，通常里面會綁定fd回調函數以及我們需要關注的事件。 然后一旦觸發事件之后會觸發我們使用的回調函數，回調函數參數通常有reactor,watcher以及觸發的事件。這里不打算重復文檔里面的watcher 相關的內容和對應的API,但是對於某些內容的話可能會提到並且附帶一些注釋。之前我們還是看看通用過程，這里使用TYPE區分不同類型watcher.

typedef void (*)(struct ev_loop *loop, ev_TYPE *watcher, int revents) callback; // callback都是這種類型
ev_init (ev_TYPE *watcher, callback); // 初始化watcher
ev_TYPE_set (ev_TYPE *watcher, [args]); // 設置watcher
ev_TYPE_init (ev_TYPE *watcher, callback, [args]); // 通常使用這個函數最方便，初始化和設置都在這里
ev_TYPE_start (loop, ev_TYPE *watcher); // 注冊watcher
ev_TYPE_stop (loop, ev_TYPE *watcher); // 注銷watcher
ev_set_priority (ev_TYPE *watcher, int priority); // 設置優先級
ev_feed_event (loop, ev_TYPE *watcher, int revents); // 這個做跨線程通知非常有用，相當於觸發了某個事件。
bool ev_is_active (ev_TYPE *watcher); // watcher是否active.
bool ev_is_pending (ev_TYPE *watcher); // watcher是否pending.
int ev_clear_pending (loop, ev_TYPE *watcher); // 清除watcher pending狀態並且返回事件

　　wacther的狀態有下面這么幾種：

　　(1) initialiased.調用init函數初始化
　　(2) active.調用start進行注冊
　　(3) pending.已經觸發事件但是沒有處理
　　(4) inactive.調用stop注銷。這個狀態等同於initialised這個狀態。

　　ev_io

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


static void stdin_callback(struct ev_loop *loop,ev_io *w,int revents)
{
    char str[1024];
    if(revents & EV_READ)
    {
        //stdin might have data for us
        printf("有數據可讀\n");
        scanf("%s",str);
        ev_io_stop(loop,w);
    }
    else if(revents & EV_WRITE)
    {
        //stdout might have data for us
        printf("有數據輸出\n");
        //ev_break(loop,EVBREAK_ONE);
    }
    printf("water:%d\n",ev_is_active(w));
}

int main(int argc,char **argv)
{
    struct ev_loop * main_loop = ev_default_loop(0);
    //這里的ev_default_loop可以使用ev_loop_new動態分配一個，然后使用ev_loop_destroy銷毀。
    //struct ev_loop * epoller = ev_loop_new(EVBACKEND_EPOLL | EVFLAG_NOENV);
    //這里一般是使用EVBACKEND_EPOLL模型，同樣的還有EVBACKEND_SELECT EVBACKEND_POLL EVBACKEND_KQUEUE EVBACKEND_DEVPOLL EVBACKEND_PORT 如果默認，那么ev會自動判斷系統環境，選擇最適合的模型，Linux一般為epoll bsd一般為kqueue什么的。
    ev_io stdin_watcher;
    ev_init(&stdin_watcher,stdin_callback);
    ev_io_set(&stdin_watcher,STDIN_FILENO,EV_READ|EV_WRITE);
    ev_io_start(main_loop,&stdin_watcher);

    //ev_run(main_loop,EVRUN_ONCE);

    //void ev_set_io_collect_interval (EV_P_ ev_tstamp interval);//這個是設置輪詢的時間
    //typedef double ev_tstamp
    ev_set_io_collect_interval(main_loop,2.);//2秒
    ev_run(main_loop,0);
    //ev_is_active(ev_TYPE * watcher);//用於判斷watcher是否為active
    printf("main:%d\n",ev_is_active(&stdin_watcher));

    //initialiased.調用init函數初始化
    //active.調用start進行注冊
    //pending.已經觸發事件但是沒有處理
    //inactive.調用stop注銷。這個狀態等同於initialised這個狀態

    return 0;
}

　　ev_timer

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

static void three_second_callback(struct ev_loop *loop,ev_timer *w,int revents)
{
    //這是一個3秒觸發的計時器
    printf("3秒觸發器\n");
}
static void five_second_callback(struct ev_loop *loop,ev_timer *w,int revents)
{
    //這是一個5秒觸發的計時器
    printf("5秒觸發器\n");
}
static void the_second_callback(struct ev_loop *loop,ev_timer *w,int revents)
{
    //這是一個10秒觸發的計時器
    printf("10秒觸發器\n");
}

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

    ev_timer mytimer_watcher3;
    ev_timer mytimer_watcher5;

    ev_init(&mytimer_watcher3,three_second_callback);
    ev_timer_set(&mytimer_watcher3,3,0);
    ev_timer_start(main_loop,&mytimer_watcher3);
    ev_run(main_loop,0);//這個在ev_io上是一直判斷的。但是這個觸發器只會觸發一次，不會每3秒觸發一次。這是個問題。

    ev_init(&mytimer_watcher5,five_second_callback);
    ev_timer_set(&mytimer_watcher5,5,0);
    ev_timer_start(main_loop,&mytimer_watcher5);
    ev_run(main_loop,0);


    ev_timer_start(main_loop,&mytimer_watcher3);
    ev_timer_start(main_loop,&mytimer_watcher5);
    ev_run(main_loop,0);//這里不會等待3，5秒，而是上一步后，直接輸出,可見觸發器只能用一次

    ev_timer_set(&mytimer_watcher3,3,0);
    ev_timer_start(main_loop,&mytimer_watcher3);
    ev_timer_set(&mytimer_watcher5,5,0);
    ev_timer_start(main_loop,&mytimer_watcher5);
    ev_run(main_loop,0);//這里就會等待了，要重新set一遍


    return 0;
}

　　運行的結果是在第3秒輸出(3秒觸發器)，第8秒輸出(5秒觸發器)(3秒觸發器)(5秒觸發器)，第11秒輸出(3秒觸發器)，第13秒輸出(5秒觸發器)。

　　這個ev_timer居然不能重復，是不是沒有解決辦法呢？不是還有個ev_periodic這個可以實現周期性觀察器。 

　　ev_periodic

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

static void periodic_callback(struct ev_loop *loop,ev_periodic * w, int revents)
{
    printf("每3秒執行一次\n");
    //ev_break(loop,EVBREAK_ALL);
}

//ev_tstamp=double
static ev_tstamp periodic_scheduler_callback(ev_periodic *w,ev_tstamp now)
{
    return now+3;//注意時間要加上個now，是一個絕對時間
}

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

    ev_periodic periodic_watcher;
    //下面這個是第3個參數為3 是一個表達式
    ev_init(&periodic_watcher,periodic_callback);
    ev_periodic_set(&periodic_watcher,0,3,0);
    ev_periodic_start(main_loop,&periodic_watcher);
    ev_run(main_loop,0);

    //如果時間周期計算方式，不能通過一個表達式來表示，那么可以通過一個函數來表示，放在set的第4個參數
    ev_init(&periodic_watcher,periodic_callback);
    ev_periodic_set(&periodic_watcher,0,0,periodic_scheduler_callback);
    ev_periodic_start(main_loop,&periodic_watcher);
    ev_run(main_loop,0);
    //注意上下兩部分不能通過運行，要注釋掉一個才可以看到效果
    return 0;
}

　　ev_signal

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

static void sigint_callback(struct ev_loop * loop,ev_signal *w,int revents)
{
    if(revents & EV_SIGNAL)//用這個可以判斷這次進來的是不是ev_signal 如果一個callback回調函數復用的話，就可以用這個來區分
    {
        printf("signal SIGINT\n");
        ev_break(loop, EVBREAK_ALL);
    }
}

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

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

    ev_signal sigint_watcher;
    ev_signal sigquit_watcher;

    ev_init(&sigint_watcher,sigint_callback);
    ev_signal_set(&sigint_watcher,SIGINT/*Other want to catch*/);//這里多個信號不能用或符號| 連接起來
    ev_signal_start(main_loop,&sigint_watcher);

    ev_init(&sigquit_watcher,sigquit_callback);
    ev_signal_set(&sigquit_watcher,SIGQUIT/*Other want to catch*/);
    ev_signal_start(main_loop,&sigquit_watcher);

    ev_run(main_loop,0);

    return 0;
}

　　運行程序，輸入Ctrl-C或Ctrl-\都是可以捕獲的。

　　ev_child

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <ev.h>

static void child_callback(struct ev_loop *loop,ev_child *w,int revents)
{
    ev_child_stop(loop,w);
    printf("Process %d exited with status %d\n",w->rpid,w->rstatus);
}

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

    ev_child child_watcher;

    pid=fork();
    if(pid<0)
    {
        printf("Fork Error\n");
        return -1;
    }
    else if(pid==0)//child
    {
        printf("child doing..\n");
        return 0;
    }
    else //father
    {
        sleep(2);//即使讓子進程先執行，最后還是可以捕獲到。
        ev_init(&child_watcher,child_callback);
        ev_child_set(&child_watcher,pid,0);
        //ev_child_start(EV_DEFAULT_ &child_watcher);
        ev_child_start(main_loop,&child_watcher);
        ev_run(main_loop,0);
    }

    //waitpid(pid,0,0);
    return 0;
}

　　上面的例子，主進程通過pid將子進程綁定到了child_callback事件中，當子進程掛掉后，主進程就能捕捉的信號，然后調用child_callback函數。

　　另一個測試場景：

　　1 主進程啟動后啟動一個子進程。
　　2 手動通過后台kill命令，kill掉子進程。
　　3 主進程收到信息，打印出提示。

　　上面代碼第30行修改為while(1) ;  然后在第34行增加一行printf("pid:%d\n",pid); 然后運行，結果如下:

　　注意上面有些是命令，有些是輸出的中間結果。這樣看起來很亂，但是終端運行結果就是這樣。第1、6行是命令。

　　ev_stat

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

static void stat_callback(struct ev_loop *loop,ev_stat *w, int revents)
{
    if(w->attr.st_nlink)
    {
        printf("The file size %ld\n",(long)w->attr.st_size);
    }
    else
    {
        printf("文件不存在\n");
    }
}

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

    ev_stat stat_watcher;
    ev_init(&stat_watcher,stat_callback);
    ev_stat_set(&stat_watcher,"/home/myuser/hello.txt",0);
    ev_stat_start(main_loop,&stat_watcher);

    ev_run(main_loop,0);
    return 0;
}

　　我們創建hello.txt這個文件，然后輸入字符，然后保存，然后再打開，修改就這樣。運行過程圖

　　文件attr的其他屬性。

文檔原文:The previous attributes of the file. The callback gets invoked whenever
C<prev> != C<attr>, or, more precisely, one or more of these members
differ: C<st_dev>, C<st_ino>, C<st_mode>, C<st_nlink>, C<st_uid>,
C<st_gid>, C<st_rdev>, C<st_size>, C<st_atime>, C<st_mtime>, C<st_ctime>
文檔解釋:如果以前的文件有一點修改，無論是什么屬性，都將觸發這個回調函數。這個attr文件在這里可以獲取到的屬性成員有

　　我們的stat_callback函數修改如下:

static void stat_callback(struct ev_loop *loop,ev_stat *w, int revents)
{
    if(w->attr.st_nlink)
    {
        printf("The file st_dev %d\n",w->attr.st_dev);
        printf("The file st_ino %d\n",w->attr.st_ino);
        printf("The file st_mode %d\n",w->attr.st_mode);
        printf("The file st_nlink %d\n",w->attr.st_nlink);
        printf("The file st_uid %d\n",w->attr.st_uid);
        printf("The file st_gid %d\n",w->attr.st_gid);
        printf("The file st_rdev %d\n",w->attr.st_rdev);
        printf("The file st_size %d\n",w->attr.st_size);
        printf("The file st_atime %d\n",w->attr.st_atime);
        printf("The file st_mtime %d\n",w->attr.st_mtime);
        printf("The file st_ctime %d\n",w->attr.st_ctime);
    }
    else
    {
        printf("文件不存在\n");
    }
}

　　運行結果:

　　至於那些st_*的屬性就不用說了，跟系統函數stat調用的返回結果是一樣的。都是通用的。

　　這一節到這里就結束了，這一節了解了幾個最主要的watcher了。除了上面的幾個外，還有下面這幾個 ev_idle ev_prepare/ev_check ev_embed ev_fork ev_cleanup ev_async .

 

 

  

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