Libuv教程

到目前为止写了挺多网络编程的东西,要么用netty,要么用go。因为网络编程是IO密集的应用,用带gc的语言写,总是因为频繁的gc需求导致cpu占用过高。netty使用unsafepointer的使用堆外内存来避免频繁gc,但是这还是不够,因为你总得生成string这种堆内对象。只有一个办法来避免这种问题,那就是用没有gc的语言来编写网络编程了。

libuv就是c语言的一个异步事件库,这篇博客就是来搞一下。

编译安装libuv

wget https://codeload.github.com/libuv/libuv/zip/v1.30.0 -O libuv-1.30.0.zip
unzip libuv-1.30.0.zip
cd libuv-1.30.0
apt install automake libtool autoconf
bash autogen.sh
./configure --prefix=/usr
make
make install

一个没有handle的loop

# 使用cat编辑a.c
cat > a.c << EOF
#include <stdio.h>
#include <stdlib.h>
#include <uv.h>

int main() {
    uv_loop_t *loop = malloc(sizeof(uv_loop_t));
    uv_loop_init(loop);

    printf("Now quitting.\n");
    uv_run(loop, UV_RUN_DEFAULT);

    uv_loop_close(loop);
    free(loop);
    return 0;
}
EOF

编译运行

gcc a.c -luv -o a&&./a

# Now quitting.

说明

这个例子创建了一个loop,该loop经历了malloc、init、run、close、free五个阶段,其中malloc和free是c语言内存管理,init、run、close则是loop的生命周期。

这个程序会马上退出,因为loop上没有注册监听的事件。

带有idle handle的loop

这个例子给loop增加一个idle handle,可以认为这是cpu进入空闲的事件。

下面这个例子使用uv_default_loop()代替了上个例子的malloc和init,同时也没有显式得free这个default loop。

这个例子的重点是创建了一个名为“idler”的handle,并将其注册到loop中,然后启动loop。代码如下:

     uv_idle_t idler;

    uv_idle_init(uv_default_loop(), &idler);
    uv_idle_start(&idler, count_check_stop);
  1. uv_idle_t idler;——在栈上分配一个idle handle
  2. uv_idle_init(uv_default_loop(), &idler);——注册该handle到default loop
  3. uv_idle_start(&idler, count_check_stop);——注册该handle的回调为count_check_stop函数
  4. uv_run(uv_default_loop(), UV_RUN_DEFAULT);——loop开始循环
  5. ……

uv_run执行后,每当idle事件发生时,都会调用count_check_stop函数,会对计数器加一,如果计数器大于5000000,则会uv_idle_stop这个handle(移除该handle)。这导致loop中没有handle等待触发,所以loop也会退出整个进程退出。

总结一下,在loop的malloc、init后,需要注册handle,完成handle的内存分配、init(注册到loop)、start(注册回调函数)。需要移除该handle时对该handle执行stop。

#include <stdio.h>
#include <uv.h>

int64_t counter = 0;

void count_check_stop(uv_idle_t* handle) {
    counter++;

    if(counter%1000000==0){
        printf("%ld idle\n",counter/1000000);

    }

    if (counter >= 5000000) {
        printf("Idle stop!");
        uv_idle_stop(handle);
    }
}

int main() {
    uv_idle_t idler;

    uv_idle_init(uv_default_loop(), &idler);
    uv_idle_start(&idler, count_check_stop);

    printf("Idling...\n");
    uv_run(uv_default_loop(), UV_RUN_DEFAULT);

    uv_loop_close(uv_default_loop());
    return 0;
}

输出

Idling...
1 idle
2 idle
3 idle
4 idle
5 idle
Idle stop!

echoserver的实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

#define DEFAULT_PORT 7000
#define DEFAULT_BACKLOG 128

uv_loop_t *loop;
struct sockaddr_in addr;
const char * ENTER="请输入任意文字:\n";

typedef struct {
    uv_write_t req;
    uv_buf_t buf;
} write_req_t;

void free_write_req(uv_write_t *req) {
    write_req_t *wr = (write_req_t*) req;
    free(wr->buf.base);
    free(wr);
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
    buf->base = (char*) malloc(suggested_size);
    buf->len = suggested_size;
}

void echo_write(uv_write_t *req, int status) {
    if (status) {
        fprintf(stderr, "Write error %s\n", uv_strerror(status));
    }
    free_write_req(req);
}

void first_write(uv_write_t *req, int status){
    if (status) {
        fprintf(stderr, "Write error %s\n", uv_strerror(status));
    }else{
        fprintf(stderr,"提示发送成功\n");
    }

    write_req_t *wr = (write_req_t*) req;
    free(wr);
}

void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {

    if (nread > 0) {
        //截取char*,增加\0
        buf->base[nread]=0;
        fprintf(stderr,"%ld:%s",nread,buf->base);

        write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
        req->buf = uv_buf_init(buf->base, nread);
        uv_write((uv_write_t*) req, client, &req->buf, 1, echo_write);
        return;
    }
    if (nread < 0) {
        if (nread != UV_EOF)
            fprintf(stderr, "Read error %s\n", uv_err_name(nread));
        uv_close((uv_handle_t*) client, NULL);
    }

    free(buf->base);
}

void on_new_connection(uv_stream_t *server, int status) {
    if (status < 0) {
        fprintf(stderr, "New connection error %s\n", uv_strerror(status));
        // error!
        return;
    }

    uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
    uv_tcp_init(loop, client);
    if (uv_accept(server, (uv_stream_t*) client) == 0) {
        //发送提示信息
        write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
        req->buf = uv_buf_init((char *)ENTER, strlen(ENTER));
        uv_write((uv_write_t*) req,(uv_stream_t*)  client, &req->buf, 1, first_write);

        uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);
    }
    else {
        uv_close((uv_handle_t*) client, NULL);
    }
}

int main() {
    loop = uv_default_loop();

    uv_tcp_t server;
    uv_tcp_init(loop, &server);

    uv_ip4_addr("0.0.0.0", DEFAULT_PORT, &addr);

    uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
    int r = uv_listen((uv_stream_t*) &server, DEFAULT_BACKLOG, on_new_connection);
    if (r) {
        fprintf(stderr, "Listen error %s\n", uv_strerror(r));
        return 1;
    }
    return uv_run(loop, UV_RUN_DEFAULT);
}
nc localhost 7000
# 输入一些东西
# echo 你输入的东西