libevent源码深度剖析之队列

最新推荐文章于 2021-05-21 05:12:46 发布
最新推荐文章于 2021-05-21 05:12:46 发布
阅读量311 收藏
点赞数
分类专栏： libevent源码深度剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36709685/article/details/105916217
版权

一、单链表

/*
 * Singly-linked List definitions.
 */
#define SLIST_HEAD(name, type)						\
struct name {								\
	struct type *slh_first;	/* first element */			\
}

#define	SLIST_HEAD_INITIALIZER(head)					\
	{ NULL }

#ifndef _WIN32
#define SLIST_ENTRY(type)						\
struct {								\
	struct type *sle_next;	/* next element */			\
}
#endif

/*
 * Singly-linked List access methods.
 */
#define	SLIST_FIRST(head)	((head)->slh_first)
#define	SLIST_END(head)		NULL
#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)

#define	SLIST_FOREACH(var, head, field)					\
	for((var) = SLIST_FIRST(head);					\
	    (var) != SLIST_END(head);					\
	    (var) = SLIST_NEXT(var, field))

/*
 * Singly-linked List functions.
 */
#define	SLIST_INIT(head) {						\
	SLIST_FIRST(head) = SLIST_END(head);				\
}

#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
	(slistelm)->field.sle_next = (elm);				\
} while (0)

#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.sle_next = (head)->slh_first;			\
	(head)->slh_first = (elm);					\
} while (0)

#define	SLIST_REMOVE_HEAD(head, field) do {				\
	(head)->slh_first = (head)->slh_first->field.sle_next;		\
} while (0)

注释：

struct Data
{
    SLIST_ENTRY(Data) next;
    int m_iData;
    //other object..
};

1、利用宏SLIST_HEAD定义一个表头
SLIST_HEAD(myHead, Data);

struct myHead{								\
	struct Data*slh_first;	/* first element */			\
}
struct myHead{								\
	struct Data
	{
	    struct {								\
			struct Data*sle_next;	/* next element */			\
		}next;
	    int m_iData;
	    //other object..
	}*slh_first;	/* first element */			\
}

static struct myHead listHead;

2、初始化SLIST_INIT：
在这里插入图片描述
SLIST_INSERT_HEAD(head, elm, field)：
3、利用宏SLIST_EMPTY来判断一个链表是否为空

if (SLIST_EMPTY(&listHead)) {
    printf("this Singly-linked List is null!\r\n");
}

即：判断listHead->slh_first是否为空
4、利用宏SLIST_INSERT_HEAD向表头插入一个对象
struct Data listDataElm1 = { NULL, 1 };
SLIST_INSERT_HEAD(&listHead, &listDataElm1, next);
在这里插入图片描述5、利用宏SLIST_INSERT_AFTER向链表的尾部添加对象
struct Data listDataElm1 = { NULL, 2 };
SLIST_INSERT_AFTER(&listDataElm1, &listDataElm2, next);
在这里插入图片描述70)6、 利用宏SLIST_REMOVE_AFTER向链表的头部移除对象
SLIST_REMOVE_AFTER(&listDataElm2, next);
7、

#define	SLIST_FOREACH(var, head, field)					\
	for((var) = SLIST_FIRST(head);					\
	    (var) != SLIST_END(head);					\
	    (var) = SLIST_NEXT(var, field))

宏名称                      操作
TAILQ_INIT   			初始化队列
TAILQ_FOREACH			对队列进行遍历操作
TAILQ_INSERT_BEFORE		在指定元素之前插入元素
TAILQ_INSERT_TAIL		在队列尾部插入元素
TAILQ_EMPTY				检查队列是否为空
TAILQ_REMOVE			从队列中移除元素

第二章 链表


/*
 * List definitions.
 */
#define LIST_HEAD(name, type)						\
struct name {								\
	struct type *lh_first;	/* first element */			\
}

#define LIST_HEAD_INITIALIZER(head)					\
	{ NULL }

#define LIST_ENTRY(type)						\
struct {								\
	struct type *le_next;	/* next element */			\
	struct type **le_prev;	/* address of previous next element */	\
}

/*
 * List access methods
 */
#define	LIST_FIRST(head)		((head)->lh_first)
#define	LIST_END(head)			NULL
#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
#define	LIST_NEXT(elm, field)		((elm)->field.le_next)

#define LIST_FOREACH(var, head, field)					\
	for((var) = LIST_FIRST(head);					\
	    (var)!= LIST_END(head);					\
	    (var) = LIST_NEXT(var, field))

/*
 * List functions.
 */
#define	LIST_INIT(head) do {						\
	LIST_FIRST(head) = LIST_END(head);				\
} while (0)

#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
		(listelm)->field.le_next->field.le_prev =		\
		    &(elm)->field.le_next;				\
	(listelm)->field.le_next = (elm);				\
	(elm)->field.le_prev = &(listelm)->field.le_next;		\
} while (0)

#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.le_prev = (listelm)->field.le_prev;		\
	(elm)->field.le_next = (listelm);				\
	*(listelm)->field.le_prev = (elm);				\
	(listelm)->field.le_prev = &(elm)->field.le_next;		\
} while (0)

#define LIST_INSERT_HEAD(head, elm, field) do {				\
	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
	(head)->lh_first = (elm);					\
	(elm)->field.le_prev = &(head)->lh_first;			\
} while (0)

#define LIST_REMOVE(elm, field) do {					\
	if ((elm)->field.le_next != NULL)				\
		(elm)->field.le_next->field.le_prev =			\
		    (elm)->field.le_prev;				\
	*(elm)->field.le_prev = (elm)->field.le_next;			\
} while (0)

#define LIST_REPLACE(elm, elm2, field) do {				\
	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
		(elm2)->field.le_next->field.le_prev =			\
		    &(elm2)->field.le_next;				\
	(elm2)->field.le_prev = (elm)->field.le_prev;			\
	*(elm2)->field.le_prev = (elm2);				\
} while (0)

注释：

struct Data
{
	struct {								\
		struct Data*le_next;	/* next element */			\
		struct Data**le_prev;	/* address of previous next element */	\
	}next;
    int m_iData;
    //other object..
};

第三章 简单队列

/*
 * Simple queue definitions.
 */
#define SIMPLEQ_HEAD(name, type)					\
struct name {								\
	struct type *sqh_first;	/* first element */			\
	struct type **sqh_last;	/* addr of last next element */		\
}

#define SIMPLEQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).sqh_first }

#define SIMPLEQ_ENTRY(type)						\
struct {								\
	struct type *sqe_next;	/* next element */			\
}

/*
 * Simple queue access methods.
 */
#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
#define	SIMPLEQ_END(head)	    NULL
#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)

#define SIMPLEQ_FOREACH(var, head, field)				\
	for((var) = SIMPLEQ_FIRST(head);				\
	    (var) != SIMPLEQ_END(head);					\
	    (var) = SIMPLEQ_NEXT(var, field))

/*
 * Simple queue functions.
 */
#define	SIMPLEQ_INIT(head) do {						\
	(head)->sqh_first = NULL;					\
	(head)->sqh_last = &(head)->sqh_first;				\
} while (0)

#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(head)->sqh_first = (elm);					\
} while (0)

#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.sqe_next = NULL;					\
	*(head)->sqh_last = (elm);					\
	(head)->sqh_last = &(elm)->field.sqe_next;			\
} while (0)

#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(listelm)->field.sqe_next = (elm);				\
} while (0)

#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do {			\
	if (((head)->sqh_first = (elm)->field.sqe_next) == NULL)	\
		(head)->sqh_last = &(head)->sqh_first;			\
} while (0)

实例：

1、 定义一个数据结构体

struct Data
{
    SIMPLEQ_ENTRY(Data) next;
    int value;
    //other object..
};

等价于：

struct Data
{
	struct {								\
		struct Data*sqe_next;	/* next element */			\
	}next;
    int value;
    //other object..
};

2、初始化数据头SIMPLEQ_HEAD(myHead, Data) head;

#define SIMPLEQ_HEAD(name, type)					\
struct myHead{								\
	struct Data*sqh_first;	/* first element */			\
	struct Data**sqh_last;	/* addr of last next element */		\
}

等价于：

struct myHead head；

3、SIMPLEQ_INIT(head)

在这里插入图片描述

4、SIMPLEQ_INSERT_HEAD(head, elm, field)0)

在这里插入图片描述

5、SIMPLEQ_INSERT_TAIL(head, elm, field)

6、SIMPLEQ_FOREACH(var, head, field) 遍历

/*
 * Tail queue definitions.
 */
TAILQ_HEAD(event_configq, event_config_entry) entries;

#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

#define TAILQ_HEAD(name, type)						\
struct name {								\
	struct type *tqh_first;	/* first element */			\
	struct type **tqh_last;	/* addr of last next element */		\
}
等价于:
#define TAILQ_HEAD(name, type)						\
struct event_configq{								\
	struct event_config_entry *tqh_first;	/* first element */			\
	struct event_config_entry **tqh_last;	/* addr of last next element */		\
}
struct event_config_entry {
	struct {								\
		struct type *tqe_next;	/* next element */			\
		struct type **tqe_prev;	/* address of previous next element */	\
	}next;
	const char *avoid_method;
};

#define TAILQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).tqh_first }

#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

/*
 * tail queue access methods
 */
#define	TAILQ_FIRST(head)		((head)->tqh_first)
#define	TAILQ_END(head)			NULL
#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
#define TAILQ_LAST(head, headname)					\
	(*(((struct headname *)((head)->tqh_last))->tqh_last))
/* XXX */
#define TAILQ_PREV(elm, headname, field)				\
	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
#define	TAILQ_EMPTY(head)						\
	(TAILQ_FIRST(head) == TAILQ_END(head))

#define TAILQ_FOREACH(var, head, field)					\
	for((var) = TAILQ_FIRST(head);					\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_NEXT(var, field))

#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
	for((var) = TAILQ_LAST(head, headname);				\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_PREV(var, headname, field))

/*
 * Tail queue functions.
 */
#define	TAILQ_INIT(head) do {						\
	(head)->tqh_first = NULL;					\
	(head)->tqh_last = &(head)->tqh_first;				\
} while (0)

#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
		(head)->tqh_first->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(head)->tqh_first = (elm);					\
	(elm)->field.tqe_prev = &(head)->tqh_first;			\
} while (0)

#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.tqe_next = NULL;					\
	(elm)->field.tqe_prev = (head)->tqh_last;			\
	*(head)->tqh_last = (elm);					\
	(head)->tqh_last = &(elm)->field.tqe_next;			\
} while (0)

#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(listelm)->field.tqe_next = (elm);				\
	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
} while (0)

#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
	(elm)->field.tqe_next = (listelm);				\
	*(listelm)->field.tqe_prev = (elm);				\
	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
} while (0)

#define TAILQ_REMOVE(head, elm, field) do {				\
	if (((elm)->field.tqe_next) != NULL)				\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    (elm)->field.tqe_prev;				\
	else								\
		(head)->tqh_last = (elm)->field.tqe_prev;		\
	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
} while (0)

#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
		(elm2)->field.tqe_next->field.tqe_prev =		\
		    &(elm2)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm2)->field.tqe_next;		\
	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
	*(elm2)->field.tqe_prev = (elm2);				\
} while (0)

/*
 * Circular queue definitions.
 */
#define CIRCLEQ_HEAD(name, type)					\
struct name {								\
	struct type *cqh_first;		/* first element */		\
	struct type *cqh_last;		/* last element */		\
}

#define CIRCLEQ_HEAD_INITIALIZER(head)					\
	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

#define CIRCLEQ_ENTRY(type)						\
struct {								\
	struct type *cqe_next;		/* next element */		\
	struct type *cqe_prev;		/* previous element */		\
}

/*
 * Circular queue access methods
 */
#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
#define	CIRCLEQ_END(head)		((void *)(head))
#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
#define	CIRCLEQ_EMPTY(head)						\
	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

#define CIRCLEQ_FOREACH(var, head, field)				\
	for((var) = CIRCLEQ_FIRST(head);				\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_NEXT(var, field))

#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
	for((var) = CIRCLEQ_LAST(head);					\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_PREV(var, field))

/*
 * Circular queue functions.
 */
#define	CIRCLEQ_INIT(head) do {						\
	(head)->cqh_first = CIRCLEQ_END(head);				\
	(head)->cqh_last = CIRCLEQ_END(head);				\
} while (0)

#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
	(elm)->field.cqe_prev = (listelm);				\
	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
		(head)->cqh_last = (elm);				\
	else								\
		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
	(listelm)->field.cqe_next = (elm);				\
} while (0)

#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm);				\
	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
		(head)->cqh_first = (elm);				\
	else								\
		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
	(listelm)->field.cqe_prev = (elm);				\
} while (0)

#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.cqe_next = (head)->cqh_first;			\
	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
	if ((head)->cqh_last == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm);				\
	else								\
		(head)->cqh_first->field.cqe_prev = (elm);		\
	(head)->cqh_first = (elm);					\
} while (0)

#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
	(elm)->field.cqe_prev = (head)->cqh_last;			\
	if ((head)->cqh_first == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm);				\
	else								\
		(head)->cqh_last->field.cqe_next = (elm);		\
	(head)->cqh_last = (elm);					\
} while (0)

#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm)->field.cqe_prev;		\
	else								\
		(elm)->field.cqe_next->field.cqe_prev =			\
		    (elm)->field.cqe_prev;				\
	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm)->field.cqe_next;		\
	else								\
		(elm)->field.cqe_prev->field.cqe_next =			\
		    (elm)->field.cqe_next;				\
} while (0)

#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_last = (elm2);				\
	else								\
		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_first = (elm2);				\
	else								\
		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
} while (0)
许糖豆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Libevent源码分析——队列
WuYujun's blog
06-14 373
在compat/sys/queue.h文件里定义了5种数据结构，分别是单链表、双链表、简单队列、尾队列、环形队列，其中 TAILQ_QUEUE尾队列是libevent里使用最多的,libevent中用到的队列其实也是尾队列，所以这里只分析尾队列TAILQ_QUEUE，其他结构都大同小异，TAILQ_QUEUE队列的结构体如下： /* * Tail queue definitions. */ #define TAILQ_HEAD(name, type)...
libevent中的尾队列
zhwenx3的博客
06-11 622
一、前言 在 libevent 源码中，包括 注册事件队列(eventqueue) 和 激活事件队列(activequeues) 在内的很多地方都用到了 尾队列 这种数据结构。而 尾队列 的实现有点复杂，因此写一篇博客分析一下~ 二、相关结构体 2.1 Entry结构体 libevent 中尾队列的 Entry（即尾队列元素） 结构体定义如下： #define TAILQ_ENTRY(type) ...
libevent 事件的优先级队列
jackywgw的专栏
09-26 1981
多个事件同时触发时，libevent每一定义各个回调函数的执行顺序。可以使用优先级来定义某些事件比其它事件更重要。libevent里面的优先级队列就是active队列数组，当epoll返回event时，根据event对应的优先级放入队列的active数组列表中，实现了优先级的概念 1. event_Base的优先级队列 libevent中，每个event_base都有与之相关的一个或者多个优先级。
libevent源码–TAILQ队列，
轻飘飞扬
03-10 514
TAILQ 队列结构图 其中 tqh_first 指向队列的第一个结点 tqh_last 指向队列的最后一个结点的 tqe_next 字段 tqe_next 指向该结点的下一个结点 tqe_prev 指向该结点的上一个结点的 tqe_next 字段 根据结构图，TAILQ 队列为双向循环链表 源码 // 定义队列的头结点结构体的宏 #define TAILQ_HEAD(name, type) ...
libevent中的尾队列tailq分析
weixin_34245749的博客
11-27 95
2019独角兽企业重金招聘Python工程师标准>>> ...
libevent源码深度剖析pdf
01-16
为方便阅读，把blog上的libevent源码深度剖析系列文章整合成一个pdf。
libevent源码深度剖析
11-22
libevent源码深度剖析。。
libevent源码深度剖析 + libevent参考手册(中文版)
02-23
libevent库，文字版，很清晰，附带libevent参考手册(中文版) libevent源码深度剖析，根据libevent开源代码框架进行剖析，很不错值得学习借鉴，还有libevent中C语言的功底值得学习揣摩！
libevent数据结构尾队列
axiaojikuaipao的博客
10-17 330
1.概述 最近找来libevent的源码学习了一下,看到用宏实现的数据结构甚是惊讶,把其中尾队列的代码copy出来test了一下.个人感觉用宏实现该队列的思想是C++的模板的思想.我自己实现一个队列的思路肯定是写一个队列 中节点的结构体然后针对该结构体实现队列的基本操作.这样的队列只能使用于写好的节点….而libevent实现的版本是不依赖于实际的节点的.换句话说,我们有两个类,一个student
Libevent源码剖析基础篇——双向链表队列TAILQ
happylzs2008的专栏
05-31 226
Libevent源码剖析基础篇——双向链表队列TAILQ https://blog.csdn.net/juzihongle1/article/details/76598723 基本数据结构-队列 http://blog.chinaunix.net/uid-17240700-id-3084728.html inux queue.h之TAILQ队列分析 https://bachm...
libevent中的双端队列TAILQ
zymx(u010820135)的专栏
08-21 852
from http://wangjunle23.blog.163.com/blog/static/11783817120125302346530/ 关注的头文件： include/event2/keyvalq_struct.h event_internal.h 等文件有若干定义，具体关注 示例代码： queue.h
libevent中TAILQ_QUEUE队列的使用
willinux的专栏
05-20 143
https://blog.csdn.net/luotuo44/article/details/38374009
Libevent 事件循环(2)---事件被加入激活队列
weixin_34309435的博客
12-11 191
由Libevent 事件循环(1) 在上文中我们提到了libevent 事件循环event_dispatch 的大致过程，以epoll为例，我们看一下事件被如何加入激活队列。 //在epoll_dispatch中，epoll_wait返回可用的文件描述符号后，由fd在io_map中找到相应的io事件//void evmap_io_active_(struct event_base *ba...
libevent核心原理
zhwenx3的博客
07-12 1940
Libevent 是一个轻量级的高性能网络库，事件驱动，基于 Reactor 模式。 对 Libevent 源码的阅读可围绕事件管理展开： Libevent 对三类事件源进行了统一，用 event 结构体表示，每个 event 实例表示一个事件。 同时监听多个事件（比如监听多个 socket 上的可读事件），必然会有多个 event 实例，对这些 event 实例进行管理需要特定的数据结构，Li...
静态内存分配-链表管理（1）单向量表讲解
yzau26的博客
07-30 1084
单向链表单向量表有头节点 和节点组成，头节点主要是管理链表使用，节点组成数据。数据结构 **last指向尾节点的Next指针，在节点尾部插入节点时，直接调整头节点的last内容的指向即可在尾部插入。first指针指向链表的首节点。 value是数据，Next指向下一个节点。链表操作链表成员变量定义成员变量主要有头结点和节点，头结点不是真正的有效数据，主要是利于链表的插入，遍历等，节点是链表中
c语言中listempty函数,list_empty()和list_empty_careful()
weixin_33190667的博客
05-21 3414
大多数的读者在学习编程语言的时候都不喜欢那些枯燥的文字描述，包括我自己在开始学习编程的时候也是这样，对于代码的热情远远高于文字，所以我在我写东西的时候也不喜欢用枯燥的文字描述来向读者讲解，更喜欢用代码加上适当的文字描述的方式进行讲解，因为有些东西可能用枯燥的文字描述半天还不如实实在在的给读者呈现出一段简单的代码，让读者理解得更加的透彻些。但是并不是说文字描述就没用，文字描述也很重要，只是绝大部分读...
zephyr学习笔记---单向链表slist
abatei的专栏
03-27 1787
看了下zephyr所支持的开发板，有一个TI公司的，CC3200。低功耗wifi芯片，淘宝了一下，200出头，可以接受。当即买了一块，先弄TCP/IP再学6LowPan会好些。现在等开发板到货。 开发环境已经装好，ubuntu下开发，请参考大牛写的： http://iot-fans.xyz/zephyr/doc/v1.6.0/getting_started/installa
《STL源码剖析》---stl_slist.h阅读笔记
KangRoger的专栏
08-14 2469
slist是单向链表，不是STL标准，且功能不如list，但是slist占用空间小，某些操作代价更小。
libevent源码深度剖析下载
最新发布
08-14
通过深度剖析libevent源码，我们可以更好地理解其工作原理和实现机制。 首先，在下载libevent源码之前，我们需要确认所需的版本和平台兼容性，这样可以避免不必要的错误和兼容性问题。 在深度剖析libevent源码时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值