Libevent book 笔记(1) A tiny introduction to asynchronous IO

最新推荐文章于 2021-09-07 09:02:23 发布
最新推荐文章于 2021-09-07 09:02:23 发布
阅读量221 收藏
点赞数
分类专栏： 笔记 Libevent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MYTCHITOS/article/details/106357560
版权

闲话不多说，略过一些无关内容，直接入正题。

文章目录

第一个例子

/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE];
    size_t buffer_used;

    size_t n_written;
    size_t write_upto;

    struct event *read_event;
    struct event *write_event;
};

struct fd_state *
alloc_fd_state(struct event_base *base, evutil_socket_t fd)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;
    state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);
    if (!state->read_event) {
        free(state);
        return NULL;
    }
    state->write_event =
        event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state);

    if (!state->write_event) {
        event_free(state->read_event);
        free(state);
        return NULL;
    }

    state->buffer_used = state->n_written = state->write_upto = 0;

    assert(state->write_event);
    return state;
}

void
free_fd_state(struct fd_state *state)
{
    event_free(state->read_event);
    event_free(state->write_event);
    free(state);
}

void
do_read(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;
    char buf[1024];
    int i;
    ssize_t result;
    while (1) {
        assert(state->write_event);
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i=0; i < result; ++i)  {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                assert(state->write_event);
                event_add(state->write_event, NULL);
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        free_fd_state(state);
    } else if (result < 0) {
        if (errno == EAGAIN) // XXXX use evutil macro
            return;
        perror("recv");
        free_fd_state(state);
    }
}

void
do_write(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;

    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN) // XXX use evutil macro
                return;
            free_fd_state(state);
            return;
        }
        assert(result != 0);

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 1;

    event_del(state->write_event);
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) { // XXXX eagain??
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd); // XXX replace all closes with EVUTIL_CLOSESOCKET */
    } else {
        struct fd_state *state;
        evutil_make_socket_nonblocking(fd);
        state = alloc_fd_state(base, fd);
        assert(state); /*XXX err*/
        assert(state->write_event);
        event_add(state->read_event, NULL);
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new();
    if (!base)
        return; /*XXXerr*/

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

这里的流程是这样的

  1. 创建一个用于监听的socket
  2. 为这个socket注册连接事件及连接回调函数
  3. 在连接回调函数中，注册读事件和读回调函数
  4. 在读回调函数中，读取数据，处理数据
  5. 如果需要返回数据，则注册写事件和写回调函数，需要注意的是，写事件只能在这里注册，而不能在连接回调函数中，如果不在这里注册写事件，那么写回调函数将不会在正确的时机调用，这涉及到Libevent对读事件的处理机制，将来会有详细说明。
  6. 写回调函数最后需要移除写事件，这也是基于libevent机制所必须的，其原因也有待将来解释，虽然对于这个实例程序而言，这里的原因并不怎么明显。

对于上面5、6两步的了解和理解是很重要的。

第二个例子

/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

void
readcb(struct bufferevent *bev, void *ctx)
{
    struct evbuffer *input, *output;
    char *line;
    size_t n;
    int i;
    input = bufferevent_get_input(bev);
    output = bufferevent_get_output(bev);

    while ((line = evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) {
        for (i = 0; i < n; ++i)
            line[i] = rot13_char(line[i]);
        evbuffer_add(output, line, n);
        evbuffer_add(output, "\n", 1);
        free(line);
    }

    if (evbuffer_get_length(input) >= MAX_LINE) {
        /* Too long; just process what there is and go on so that the buffer
         * doesn't grow infinitely long. */
        char buf[1024];
        while (evbuffer_get_length(input)) {
            int n = evbuffer_remove(input, buf, sizeof(buf));
            for (i = 0; i < n; ++i)
                buf[i] = rot13_char(buf[i]);
            evbuffer_add(output, buf, n);
        }
        evbuffer_add(output, "\n", 1);
    }
}

void
errorcb(struct bufferevent *bev, short error, void *ctx)
{
    if (error & BEV_EVENT_EOF) {
        /* connection has been closed, do any clean up here */
        /* ... */
    } else if (error & BEV_EVENT_ERROR) {
        /* check errno to see what error occurred */
        /* ... */
    } else if (error & BEV_EVENT_TIMEOUT) {
        /* must be a timeout event handle, handle it */
        /* ... */
    }
    bufferevent_free(bev);
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) {
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd);
    } else {
        struct bufferevent *bev;
        evutil_make_socket_nonblocking(fd);
        bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
        bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);
        bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);
        bufferevent_enable(bev, EV_READ|EV_WRITE);
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new();
    if (!base)
        return; /*XXXerr*/

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

这个例子与前一个例子的主要不同在于使用了bufferevent和evbuffer。从概念上说，bufferevent强调的是buffer及event，而evbuffer强调的是buffer。具体的定义当然要看具体的文档，这里只是简单的说以方便记忆。

两个例子的区别在于

  • 第二个例子没有实现do_read和do_write两个函数，只实现了一个readcb。
  • 第二个例子没有定义fd_state及相关的操作，已知fd_state包括了event和buffer，或者说bufferevent本身就是类似于fd_state的一个数据结构，此外bufferevent还封装了底层的fd。
  • 第二个例子接收完数据就直接把数据写回到bufferevent的输出缓冲中，等待合适的机会由事件循环自己把数据返回客户端，而不是注册do_write回调。对于libevent来说，这两者本质是一样的，如前面说过的，这里涉及到libevent可写事件的触发及处理机制，姑且将来再详细讨论。
  • 另外，就是evbuffer_readln这个函数，是以'\n'作为一行结束的标志的，所以如果用Telnet测试，这个程序没有问题，如果是手写客户端，发送测试字符串的时候要记得行末加上'\n'
MYTCHITOS
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libevent book
01-09
libevent book 必备参考资料，方便学习libevent网络库
LibeventBook
01-17
Libenvent 开发手册，原始英文版本。自己编译生成 PDF版本。英文好的可以参考
A tiny introduction to asynchronous IO
weixin_30362083的博客
10-01 66
http://www.wangafu.net/~nickm/libevent-book/01_intro.html These documents are Copyright (c) 2009-2010 by Nick Mathewson, and are made available under the Creative Commons Attribution-Noncom...
libevent英文book
06-25
http://www.wangafu.net/~nickm/libevent-book/ 英文文档
libeventBook（Programming with Libevent.）
11-30
libevent官网教学文档，官网下不了，我在csdn上找到的，分享出来给大家用，其他资源是在太贵了，50积分一次。。。。。我就设置个1积分吧
20121021_libevent笔记1
08-04
Libevent笔记 Libevent是一个基于事件触发的网络库，适用于Windows、Linux、BSD等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。下面是对Libevent的详细介绍和解释： 1. 事件驱动，高性能：...
LibeventBook.pdf
06-09
Libevent是一个高性能的事件通知库，支持多种类型的I/O事件，包括网络事件、定时器事件和信号事件。它被广泛应用于需要快速、可扩展和非阻塞I/O操作的应用程序中。Libevent的API设计使得它在Unix和Windows平台上都能...
Libevent book 笔记(9) Bufferevents advanced topics
MYTCHITOS的博客
05-26 431
文章目录Paired buffereventsbufferevent_pair_newbufferevent_pair_get_partnerFiltering buffereventsbufferevent_filter_newLimiting maximum single read/write sizebufferevent_set_max_single_readbufferevent_set_max_single_writebufferevent_get_max_single_readbufferev
关于libevent-book-examples_01----ROT13 server by using select() 一处bug分析及修正
jeremy的博客
09-11 184
刚刚学习libevent这个开源网络库时,在研究libevent-book examples_01 目录下有一例子，使用select（）实现rto13 server. 这个select（）的基本框架在并发连接非常少时可以用来做一个简易服务器，可以在此基础上进行相应修改即可。 此server的功能基本上就是一个 echo server. 我比较关注的是select...
Libevent参考手册（初步）
Clement
07-20 658
1. 从一万英尺外看 Libevent Libevent 是用于编写高速可移植非阻塞 IO 应用的库，其设计目标是： 可移植性：使用 libevent 编写的程序应该可以在 libevent 支持的所有平台上工作。即使 没有好的方式进行非阻塞 IO，libevent 也应该支持一般的方式，让程序可以在受限的环 境中运行。 速度：libevent 尝试使用每个平台上最高速的非阻塞 IO 实现，并且不引入太多的额外 开销。 可扩展性：libevent 被设计为程序即使需要上万个活动套接字的时候也可以良好工作。
libevent入门(转)
diewang5896的博客
11-17 369
花了两天的时间在libevent上，想总结下，就以写简单tutorial的方式吧，貌似没有一篇简单的说明，让人马上就能上手用的。 首先给出官方文档吧： http://libevent.org ，首页有个Programming with Libevent，里面是一节一节的介绍libevent，但是感觉信息量太大了，而且还是英文的-。-（当然，如果想好好用libevent，看看还是很有必要...
libevent的使用
know yourself
04-17 716
一般而言，我们有时候也需要写一些网络通信的功能，但是，用原生的TCP/UDP又让人感觉麻烦。所以，我们还是希望用某些lib。libevent就是一个很好的选择。只要花费一两个小时看了官方的文档[2]，还是很容易开始使用这个lib的。   对于客户端程序，大多数情况下只有一个连接，甚至是一问一答这样的模式。是非常简单的模式。在服务端，我们一般使用Linux，相信现在使用BSD的也少了，更不用说Wi
Linux c 开发 - libevent
自娱自乐的代码人
12-15 1万+
Libevent介绍 libevent是一个事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。著名分布式缓存软件memcached也是libevent based，而且libevent在使用上可以做到跨平台，而且根据libevent官方网站上公布的数据统计，似乎也有着非凡的性能。
LibEvent中文帮助文档--第1、2、3、4章
zhouyongku的专栏
09-07 1万+
LibEvent中文帮助文档:http://blog.csdn.net/zhouyongku LibEvent快速可移植非阻塞式网络编程
LibEvent中文帮助文档
热门推荐
zhouyongku的专栏
07-27 1万+
LibEvent中文帮助文档:http://blog.csdn.net/zhouyongku LibEvent快速可移植非阻塞式网络编程
Libevent学习笔记（一）：基本使用
耗纸的博客
05-03 2626
转载于 http://www.tuicool.com/articles/VZBRBbF 这篇还比较全面。前言其实，现在高性能网络服务器基本都是异步I/O模式构建的，而Libevent就是对select、poll、epoll等各类异步模式接口的封装，通过设置回调函数的方式，在监听文件描述符和套接字读写事件的同时，还兼任定时器和信号接收的管理工作。所以这货对高性能服务器后台开发、跨平台开发、网络开发都
Libevent : LibeventBook
Huntinux
06-28 1856
http://www.wangafu.net/~nickm/libevent-book/ 前言 以下内容是对《LibeventBook》的翻译 Chapter6 : Creating a event_base Before you can use any interesting Libevent function, you need to allocate one ...
处理大并发之三 对libevent的初步认识
feitianxuxue的专栏
07-17 1万+
处理大并发之三对libevent的初步认识 首先翻译下http://www.wangafu.net/~nickm/libevent-book/01_intro.html里的一段文章 对异步IO的一个简要介绍 大多数应用程序都是阻塞的IO调用，如果IO调用是同步（阻塞）的，它不能立即返回直到它的操作完成，或者经过了很长时间直到网络栈丢弃。当你在一个TCP连接上调用”connect()”时，
libevent中文参考手册：高性能IO库解析
"libevent 参考手册-中文版，包含libevent库的详细解析，可在GitHub找到资源：https://github.com/nmathewson/libevent-book。" Libevent 是一个强大的开源库，专为编写高性能、跨平台的非阻塞I/O应用而设计。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值