Linux网络编程（libevent）

最新推荐文章于 2024-06-15 00:30:25 发布
最新推荐文章于 2024-06-15 00:30:25 发布
阅读量301 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43873349/article/details/108278265
版权

文章目录

解决安装libevent找不到动态库

在这里插入图片描述

获取libevent支持的方法和当前系统使用的方法

event.c

//获取libevent支持的方法和当前系统使用的方法
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <event2/event.h>

int main()
{
	//获取当前系统支持的方法有哪些
	//const char **event_get_supported_methods(void);
	const char **p = event_get_supported_methods();
	int i = 0;
	while(p[i]!=NULL)
	{
		printf("[%s]  ", p[i++]);
	}
	printf("\n");
	
	//创建event_base结构体
	struct event_base *base = event_base_new();
	if(base==NULL)
	{
		printf("event_base_new error\n");
		return -1;
	}
	
	//const char * event_base_get_method(const struct event_base *base);
	printf("[%s]\n", event_base_get_method(base));
	
	//释放event_base节点
	event_base_free(base);
	
	return 0;
}

libevent开发流程

在这里插入图片描述

编写一个基于event实现的tcp服务器

  1. 创建socket—socket()
  2. 设置端口复用—setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int))
  3. 绑定–bind()
  4. 设置监听–listen()
  5. 创建地基
    struct event_base *base = event_base_new()
  6. 创建lfd对应的事件
    struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
  7. 上event_base地基
    event_add(ev, NULL);
  8. 进入事件循环
    event_base_dispatch(base);
  9. 释放资源
    event_base_free(base);
    event_free(ev);

libevent服务端实现核心思路

typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
//监听文件描述符对应的事件回调函数
void conncb(evutil_socket_t fd, short events, void *arg)
{
	struct event_base *base = (struct event_base *)arg;
	//接受新的连接
	int cfd = accept(fd, NULL, NULL);
	if(cfd>0)
	{
		//创建一个新的事件
		struct event *ev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
		event_add(ev, NULL);
	}
}

//读客户端数据对应的回调函数
void readcb(evutil_socket_t fd, short events, void *arg)
{	
	//读数据
	n = read(fd, buf, sizeof(buf));
	if(n<=0)
	{
		//从base地基上删除该事件
		close(fd);
		event_del(ev);
		event_free(ev);
	}
	//发送数据给对方
	write(fd, buf, n);
}

libevent服务端代码实现

//编写libevent服务端
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <event2/event.h>

struct event *connev = NULL;

//typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
void readcb(evutil_socket_t fd, short events, void *arg)
{
	int n;
	char buf[1024];
	memset(buf, 0x00, sizeof(buf));
	n = read(fd, buf, sizeof(buf));
	if(n<=0)
	{
		close(fd);
		//将通信文件描述符对应的事件从base地基上删除
		event_del(connev);
	}
	else
	{
		write(fd, buf, n);
	}
}

void conncb(evutil_socket_t fd, short events, void *arg)
{
	struct event_base *base = (struct event_base *)arg;

	//接受新的客户端连接
	int cfd = accept(fd, NULL, NULL);
	if(cfd>0)
	{
		//创建通信文件描述符对应的事件并设置回调函数为readcb
		connev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
		if(connev==NULL)
		{
			//退出循环
			event_base_loopexit(base, NULL);
		}
		
		//将通信文件描述符对应的事件上event_base地基
		event_add(connev, NULL);	
	}	
}

int main()
{
	//创建socket
	int lfd = socket(AF_INET, SOCK_STREAM, 0);

	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

	//绑定
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	serv.sin_port = htons(8888);
	serv.sin_family = AF_INET;
	bind(lfd, (struct sockaddr*)&serv, sizeof(serv));

	//监听
	listen(lfd, 120);

	//创建地基
	struct event_base *base = event_base_new();
	if(base==NULL)
	{
		printf("event_base_new error\n");
		return -1;
	}

	//创建监听文件描述符对应的事件
	//struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
	struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
	if(ev==NULL)
	{
		printf("event_new error\n");
		return -1;
	}

	//将新的事件节点上base地基
	event_add(ev, NULL);

	//进入事件循环等待
	event_base_dispatch(base);

	//释放资源
	event_base_free(base);
	event_free(ev);

	close(lfd);
	return 0;
}

需改进：将文件描述符和事件封装为结构体（否则connev指针保存的永远是最后一个）

//编写libevent服务端
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <event2/event.h>
#include <ctype.h>

#define MAX 1000

struct event_fd
{
		evutil_socket_t fd;
		struct event *ev;
}event[MAX];

void init_ev_fd()
{
		int i = 0;
		for(i = 0; i < MAX; ++i)
		{
				event[i].fd = -1;
				event[i].ev = NULL;
		}
}

void setEventFd(evutil_socket_t fd, struct event *ev)
{
		int i = 0;
		//查找存放的位置
		for(i = 0; i < MAX; ++i)
		{
				if(event[i].fd == -1)
				{
						break;
				}
		}
		//若找不到合适的位置，直接退出进程
		if(i == MAX)
		{
				exit(1);
		}

		event[i].fd = fd;
		event[i].ev = ev;
}

int findEv(int fd)
{
		int i = 0;
		for(i = 0; i < MAX; ++i)
		{
				if(event[i].fd == fd)
				{
						break;
				}
		}
		if(i == MAX)
		{
				printf("not find fd\n");
				exit(1);
		}
		return i;
}


//typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);
void readcb(evutil_socket_t fd, short events, void *arg)
{
		int n;
		char buf[1024];
		memset(buf, 0x00, sizeof(buf));
		int num = findEv(fd);
		n = read(fd, buf, sizeof(buf));
		if(n < 0)
		{
				perror("read error");
				close(fd);
				//将通信文件描述符对应的事件从base地基上删除
				event_del(event[num].ev);
				event[num].fd = -1;
				event[num].ev = NULL;
		}
		else if(n == 0)
		{
				printf("client close\n");
				close(fd);
				event_del(event[num].ev);
				printf("[%p], [%d]\n", event[num].ev, num);
				event[num].fd = -1;
				event[num].ev = NULL;
		}
		else
		{
				int i = 0;
				for(i = 0; i < n; ++i)
				{
					buf[i] = toupper(buf[i]);
				}
				write(fd, buf, strlen(buf));
		}
}

void conncb(evutil_socket_t fd, short events, void *arg)
{
		struct event_base *base = (struct event_base *)arg;

		//接受新的客户端连接
		struct sockaddr_in cliaddr;
		socklen_t addrlen = sizeof(struct sockaddr_in);

		int cfd = accept(fd, (struct sockaddr*)&cliaddr, &addrlen);

		if(cfd < 0)
		{
				perror("accept error");
				exit(1);
		}

		//打印客户端IP和PORT
		char sIP[128];
		memset(sIP, 0x00, sizeof(sIP));
		printf("received from %s at port %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, sIP, sizeof(sIP)), ntohs(cliaddr.sin_port));

		//创建通信文件描述符对应的事件并设置回调函数为readcb
		struct event *readev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, base);
		
		event_add(readev, NULL);
		setEventFd(cfd, readev);
}

int main()
{
		//创建socket
		int lfd = socket(AF_INET, SOCK_STREAM, 0);

		//设置端口复用
		int opt = 1;
		setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

		//绑定
		struct sockaddr_in serv;
		bzero(&serv, sizeof(serv));
		serv.sin_addr.s_addr = htonl(INADDR_ANY);
		serv.sin_port = htons(8888);
		serv.sin_family = AF_INET;
		bind(lfd, (struct sockaddr*)&serv, sizeof(serv));

		//监听
		listen(lfd, 120);

		//创建地基
		struct event_base *base = event_base_new();
		if(base==NULL)
		{
				printf("event_base_new error\n");
				return -1;
		}

		//创建监听文件描述符对应的事件
		//struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);
		struct event *ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
		if(ev==NULL)
		{
				printf("event_new error\n");
				return -1;
		}

		//将新的事件节点上base地基
		event_add(ev, NULL);

		//进入事件循环等待
		event_base_dispatch(base);

		//释放资源
		event_base_free(base);
		event_free(ev);

		close(lfd);
		return 0;
}

bufferevent

bufferevent的读事件回调触发时机:
  当数据由内核的读缓冲区到bufferevent的读缓冲区的时候, 会触发bufferevent的读事件回调.
  需要注意的是: 数据由内核到bufferevent的过程不是用户程序执行的, 而是是由bufferevent内部操作的.

bufferevent的写事件回调触发时机:
  当用户程序将数据写到bufferevent的写缓冲区之后, bufferevent会自动将数据写到内核的写缓冲区,最终有内核程序将数据发送出去.

事件回调:
  当bufferevent绑定的socket连接, 断开或者异常的时候触发事件回调.

链接监听器

在这里插入图片描述

bufferevent服务端代码

hello-world.c

/*
  This exmple program provides a trivial server program that listens for TCP
  connections on port 9995.  When they arrive, it writes a short message to
  each client connection, and closes each connection once it is flushed.

  Where possible, it exits cleanly in response to a SIGINT (ctrl-c).
*/


#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <signal.h>
#ifndef WIN32
#include <netinet/in.h>
# ifdef _XOPEN_SOURCE_EXTENDED
#  include <arpa/inet.h>
# endif
#include <sys/socket.h>
#endif

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

static const char MESSAGE[] = "Hello, World!\n";

static const int PORT = 9995;

static void listener_cb(struct evconnlistener *, evutil_socket_t,
    struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);

int
main(int argc, char **argv)
{
	struct event_base *base;    //定义了指向地基节点的指针
	struct evconnlistener *listener;  //定义了链接监听器的指针
	struct event *signal_event;  //定义了信号事件指针

	struct sockaddr_in sin;
#ifdef WIN32
	WSADATA wsa_data;
	WSAStartup(0x0201, &wsa_data);
#endif

	//创建地基节点--相当于epoll的树根
	base = event_base_new();
	if (!base) {
		fprintf(stderr, "Could not initialize libevent!\n");
		return 1;
	}

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(PORT);

	//创建链接监听器--socket bind  listen  accept
	//listener_cb--回调函数
	//LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE: 端口复用|释放连接监听器的时候关闭文件描述符
	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
	    (struct sockaddr*)&sin,
	    sizeof(sin));

	if (!listener) {
		fprintf(stderr, "Could not create a listener!\n");
		return 1;
	}

	//#define evsignal_new(b, x, cb, arg)				\
	//event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);

	if (!signal_event || event_add(signal_event, NULL)<0) {
		fprintf(stderr, "Could not create/add a signal event!\n");
		return 1;
	}

	//进入事件循环---相当于while(1)
	event_base_dispatch(base);

	//释放连接监听器
	evconnlistener_free(listener);
	//释放信号事件节点
	event_free(signal_event);
	//释放地基节点
	event_base_free(base);

	printf("done\n");
	return 0;
}

//listener: 链接监听器指针
//fd: 通信文件描述符
//sa和socklen: 客户端地址信息和长度
//user_data: 具体是地基节点指针
static void
listener_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sa, int socklen, void *user_data)
{
	printf("--call--%s--\n", __FUNCTION__);

	struct event_base *base = user_data;
	struct bufferevent *bev;//指向bufferevent的指针

	//创建bufferevent
	//BEV_OPT_CLOSE_ON_FREE: 当释放bufferevent的时候关闭连接
	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
	if (!bev) {
		fprintf(stderr, "Error constructing bufferevent!");
		event_base_loopbreak(base);
		return;
	}
	//设置回调函数---写事件和异常事件回调函数
	bufferevent_setcb(bev, NULL, conn_writecb, conn_eventcb, NULL);
	//使写事件回调生效
	bufferevent_enable(bev, EV_WRITE);
	//使读事件回调失效
	bufferevent_disable(bev, EV_READ);

	//将数据写到bufferevent的写缓冲区
	bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}

static void
conn_writecb(struct bufferevent *bev, void *user_data)
{
	printf("--call--%s--\n", __FUNCTION__);

	//获取bufferevent的写缓冲区的指针
	struct evbuffer *output = bufferevent_get_output(bev);
	//查看缓冲区还有没有数据
	if (evbuffer_get_length(output) == 0) {
		printf("flushed answer\n");
		//释放bufferevent,关闭通信文件 描述符
		bufferevent_free(bev);
	}
}

static void
conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
	printf("--call--%s--\n", __FUNCTION__);

	if (events & BEV_EVENT_EOF) {
		printf("Connection closed.\n");
	} else if (events & BEV_EVENT_ERROR) {
		printf("Got an error on the connection: %s\n",
		    strerror(errno));/*XXX win32*/
	}
	/* None of the other events can happen here, since we haven't enabled
	 * timeouts */
	bufferevent_free(bev);
}

static void
signal_cb(evutil_socket_t sig, short events, void *user_data)
{
	printf("--call--%s--\n", __FUNCTION__);

	struct event_base *base = user_data;
	struct timeval delay = { 2, 0 };

	printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");

	//事件回调函数执行完后, 再过2秒, 跳出循环, 程序结束
	event_base_loopexit(base, &delay);
}

在这里插入图片描述

bufferevent客户端代码

bufferevent_client.c

//bufferevent建立客户端的过程
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <event.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>
#include <event2/util.h>

int tcp_connect_server(const char* server_ip, int port);
void cmd_msg_cb(int fd, short events, void* arg);
void server_msg_cb(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);

int main(int argc, char** argv)
{
    if( argc < 3 )
    {
        //两个参数依次是服务器端的IP地址、端口号
        printf("please input 2 parameter\n");
        return -1;
    }
    //创建根节点
    struct event_base *base = event_base_new();
    //创建并且初始化buffer缓冲区
    struct bufferevent* bev = bufferevent_socket_new(base, -1,
                                                     BEV_OPT_CLOSE_ON_FREE);

    //监听终端输入事件 设置标准输入的监控,设置回调是 cmd_msg_cb 
    struct event* ev_cmd = event_new(base, STDIN_FILENO,
                                     EV_READ | EV_PERSIST,
                                     cmd_msg_cb, (void*)bev);
    //上树 开始监听标准输入的读事件
    event_add(ev_cmd, NULL);
    
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr) );
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(argv[2]));
    //将ip地址转换为网络字节序
    inet_aton(argv[1], &server_addr.sin_addr);

    //连接到 服务器ip地址和端口 初始化了 socket文件描述符 socket+connect 
    bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
                               sizeof(server_addr));
    //设置buffer的回调函数 主要设置了读回调 server_msg_cb ,传入参数是标准输入的读事件
    bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    event_base_dispatch(base);//循环等待
    event_free(ev_cmd);
    bufferevent_free(bev);
    event_base_free(base);
    printf("finished \n");
    return 0;
}
//终端输入回调
void cmd_msg_cb(int fd, short events, void* arg)
{
    char msg[1024];

    int ret = read(fd, msg, sizeof(msg));
    if( ret < 0 )
    {
        perror("read fail ");
        exit(1);
    }
    //得到bufferevent指针,目的是为了写到bufferevent的写缓冲区
    struct bufferevent* bev = (struct bufferevent*)arg;

    //把终端的消息发送给服务器端
    bufferevent_write(bev, msg, ret);
}

void server_msg_cb(struct bufferevent* bev, void* arg)
{
    char msg[1024];

    size_t len = bufferevent_read(bev, msg, sizeof(msg));
    msg[len] = '\0';

    printf("recv %s from server\n", msg);
}

void event_cb(struct bufferevent *bev, short event, void *arg)
{

    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");
    else if( event & BEV_EVENT_CONNECTED)
    {
        printf("the client has connected to server\n");
        return ;
    }

    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
    //释放event事件 监控读终端
    struct event *ev = (struct event*)arg;
    event_free(ev);
}
Mr.魏（魏先生）
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下libevent库的使用
AJIEIT的博客
07-23 724
libevent1.libevent的好处2.libevent的使用3.libevent编写多线程 在了解了libevent的安装后，再来了解一下它的使用，特别是进行多线程的使用。其实这个最大的好处就是他在内部帮你封装好了epoll/select多路复用，并且使用了一些设计模式（比如反应堆模式），用事件机制来简化了socket编程然后要用的时候直接把相应的文件描述符加进去即可！ 1.libevent的好处 假设有N个客户端同时往服务端通过socket写数据，用了libevent之后，你的server程序里
Linux----libevent
qq_48083892的博客
12-05 1078
libevent
Linux基础 （十八）：Libevent 库的安装与使用
最新发布
weixin_47040031的博客
06-15 834
Libevent 是一个高效的、轻量级的事件通知库用于开发需要处理大量并发连接的网络应用程序。它提供了一种机制来执行回调函数，当特定事件发生在文件描述符上，或在超时发生时，Libevent 可以处理不同类型的事件，包括 I/O 事件、信号事件和定时事件。为每种事件类型定义相应的处理回调函数。例如，针对新连接的事件，定义一个回调函数来处理新连接；针对读写事件，定义相应的回调函数来处理数据的读写操作。这些回调函数是处理事件的核心逻辑，通过它们来实现具体的业务逻辑。
Linux：Libevent简单使用
Rain的博客
08-01 1922
文章目录一、什么是Libevent二、Libevent如何使用三、Libevent简单使用实例四、Libevent简单实现TCP服务器 一、什么是Libevent Libevent: 是开源社区的一款高性能的I/O框架库。 其学习和使用者众多，例如：高性能的分布式内存对象缓存软件memcached，Google浏览器Chromium的Linux版本。 Libevent使用特点： 1.跨平台支持： Libevent支持Linux，UINX和Windows。 2.统一事件源： Libevent对I/O事件、信号
Linux环境下，安装libevent库
xyz_unknown的博客
12-01 1540
最近在进行网络编程的学习，在安装libevent库时，遇到了各种各样的问题。最后通过一条条的去搜索问题关键字，费尽千辛万苦，终于完成了安装，也能够成功的运行起来其中所提供的案例代码。所以在这里将各种零碎的问题以及解决方案整理一下，帮助大家顺心地完成安装。
Linux下libevent的简单使用
爱就是是恒久忍耐的专栏
07-01 1243
libevent是个高效的异步事件通知库，本文主要讲述在Linux下如何简单使用该库。 一 下载 本文写作时使用的版本是2.1.11，下载地址是https://github.com/libevent/libevent/releases/tag/release-2.1.11-stable 本人下载的是zip文件。 二 编译 把第一步下载的压缩文件放到linux下。 先解压，然后按照github上给的教程，在源码根目录下新建build目录，并cd进入，最后执行下面的2个命令进行编译（需要事先安装cmake
linux 网络编程-libevent
12-24
总的来说，"Linux网络编程-libevent"是一个关于使用libevent库构建多线程网络通信模块的主题。它涉及到事件驱动编程、多线程同步、套接字编程和网络协议处理等多个方面。通过学习和实践，开发者可以提升自己在Linux...
linux网络基础和网络编程
09-17
Linux网络基础和网络编程是IT领域中的重要组成部分，特别是在服务器端开发中不可或缺。本文将深入探讨这个主题，从Linux网络的基础知识开始，逐步讲解到Socket编程以及如何实现高并发服务器。 1. Linux网络基础： ...
Linux网络编程
04-02
在IT领域，Linux网络编程是开发者们不可或缺的一项技能，它涉及到如何在Linux操作系统下编写能够进行网络通信的程序。这个详细的教程涵盖了从基础到高级的网络开发内容，包括socket编程、套接字API的使用、多路复用...
libevent C++高并发网络编程
09-13
1-10 libevent在linux环境编译源码并编写测试程序 2-1 高并发网络模型select_epoll_iocp区别 2-2 libevent接口分析 2-3 libevent服务端接收连接的代码示例 2-4 libevent上下文属性配置和源码分析 2-5 获取系统所支持...
Libevent C++ 高并发网络编程
09-27
libevent 网络高并发编程视频 地址绝对有效 内部为网盘地址带有获取密码，夏曹俊主讲 开发环境：linux win32 知识：linux C/C++ 网络编程
【最新】C++ 使用libEvent实现http的post, get功能
12-01
【最新】C++ 使用libEvent实现http的post, get功能，【最新】C++ 使用libEvent实现http的post, get功能
libevent参考手册(中文版)
08-23
libevent参考手册(中文版):比较详细的介绍了libevent网络编程。
服务器并发编程--libevent
喜欢打篮球的普通人
05-05 978
Libevent 是一个用C语言编写的、轻量级的开源高性能网络库，主要有以下几个亮点：事件驱动（ event-driven），高性能;轻量级，专注于网络，不如 ACE 那么臃肿庞大；源代码相当精炼、易读；跨平台，支持 Windows、 Linux、 *BSD 和 Mac Os；支持多种 I/O 多路复用技术， epoll、 poll、 dev/poll、 select 和 kqueue 等；支持 I/O，定时器和信号等事件；注册事件优先级。Libevent 已经被广泛的应用，作为底层的网络库；
Linux下使用libevent库实现服务器端编程
staticnetwind的专栏
05-07 3516
TCP服务器端一般用到非阻塞Socket、IO复用，Linux可以支持epoll、select，而Windows支持select、IOCP，考虑平台适用性，需要对IO事件进行封装兼容； libevent是一个轻量级的高性能的网络库，使用libevent 进行服务器端开发非常方便，无须过多干涉网络编程的细节，不过还得真正去理解网络处理的原理； 同时，evbuffer内部的缓冲处理也为上层应用提供了不少便利，能够给项目开发带来可观的效率提升；
linux网络编程--libeventw网络库
weixin_45639955的博客
03-22 210
1概念 1.1什么是libevent 开源的高性能的事件触发的网络库,内部使用select、poll、epoll等系统调用管理事件机制 基于“事件”异步通信模型–>主要依赖于回调函数 1.2优点 开源 精简 跨平台 轻量级：专注于网络通信 2 libevent 框架 创建 ：event_base; struct event_base* pBase = event_base_ne...
6、libevent开发基本案例（linux网络编程）
伍粟的博客
05-13 378
//获取libevent支持的方法和当前系统使用的方法 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <event2/event.h> int main() { //获取当前系统支持的方法有哪些 //const char **event_get_supported_methods(void); const char **p = event_get_supporte
libevent编程疑难解答
热门推荐
luotuo44的专栏
09-25 1万+
前段时间阅读了libevent的源码。读完后，之前在使用libevent时的一些疑问都已经豁然开朗了。对于libevent源码的分析，可以到http://blog.csdn.net/luotuo44/article/category/2435521查看。 本文通过自问自答的形式，希望能帮助其他人解答在使用libevent时的一些疑惑。
libevent参考手册第四章：与事件一起工作
老衣的专栏
06-12 1万+
libevent参考手册第四章：与事件一起工作Nick Mathewson  著晨星           翻译老衣           整理libevent的基本操作单元是事件。每个事件代表一组条件的集合，这些条件包括：l  文件描述符已经就绪，可以读取或者写入l  文件描述符变为就绪状态，可以读取或者写入（仅对于边沿触发IO）l  超时事件l  发生某信号l 
linux网络编程和netty
01-27
Linux网络编程可以使用传统的套接字编程，也可以使用更高级的网络库，如libevent和libuv。 Netty是一个基于Java的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端。它是一个异步的、基于事件驱动的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值