skynet学习笔记源码之sknyet_mq消息队列

最新推荐文章于 2025-01-23 18:10:23 发布

从零到一万物起源

最新推荐文章于 2025-01-23 18:10:23 发布

阅读量227

点赞数

分类专栏： skynet 文章标签： queue 链表队列

本文链接：https://blog.youkuaiyun.com/qq_37715776/article/details/117135170

版权

skynet 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了Skynet系统中核心的消息队列结构，包括全局队列的单向链表实现和次级消息队列的动态扩容机制。理解这些原理有助于开发者深入掌握并发处理在分布式系统中的关键作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

消息队列是skynet非常核心的东西，每个context都会一个次级消息队列，次级消息队列会链接到全局队列，等待worker线程的处理。

全局队列

全局队列是一个单向链表，记录头尾位置，尾部入头部出。

struct global_queue {
	struct message_queue *head;
	struct message_queue *tail;
	struct spinlock lock;
};

void 
skynet_globalmq_push(struct message_queue * queue) {
	struct global_queue *q= Q;

	SPIN_LOCK(q)
	assert(queue->next == NULL);
	if(q->tail) {
		q->tail->next = queue;
		q->tail = queue;
	} else {
		q->head = q->tail = queue;
	}
	SPIN_UNLOCK(q)
}

struct message_queue * 
skynet_globalmq_pop() {
	struct global_queue *q = Q;

	SPIN_LOCK(q)
	struct message_queue *mq = q->head;
	if(mq) {
		q->head = mq->next;
		if(q->head == NULL) {
			assert(mq == q->tail);
			q->tail = NULL;
		}
		mq->next = NULL;
	}
	SPIN_UNLOCK(q)

	return mq;
}

次级消息队列

全局消息队列的结点类型为message_queue，也就是次级消息队列，里面链接的skynet_message

struct message_queue {
	struct spinlock lock;
	uint32_t handle;
	int cap;
	int head;
	int tail;
	int release;
	int in_global;
	int overload;
	int overload_threshold;
	struct skynet_message *queue;
	struct message_queue *next;
};

次级消息队列实际上是一个动态分配内存大小的数组，初始化cap数据大小为64，head,tail相对于快慢指针的应用。head记录头消息位置，tail记录下一个空位置，当push一个消息后，tail位置等于head位置，说明数组消息缓存已经满了，mq会扩容到当前大小的两倍，并且接手旧数据的消息。

void 
skynet_mq_push(struct message_queue *q, struct skynet_message *message) {
	assert(message);
	SPIN_LOCK(q)

	q->queue[q->tail] = *message;
	if (++ q->tail >= q->cap) {
		q->tail = 0;
	}

	if (q->head == q->tail) {
		expand_queue(q);
	}

	if (q->in_global == 0) {
		q->in_global = MQ_IN_GLOBAL;
		skynet_globalmq_push(q);
	}
	
	SPIN_UNLOCK(q)
}

static void
expand_queue(struct message_queue *q) {
	struct skynet_message *new_queue = skynet_malloc(sizeof(struct skynet_message) * q->cap * 2);
	int i;
	for (i=0;i<q->cap;i++) {
		new_queue[i] = q->queue[(q->head + i) % q->cap];
	}
	q->head = 0;
	q->tail = q->cap;
	q->cap *= 2;
	
	skynet_free(q->queue);
	q->queue = new_queue;
}

int
skynet_mq_pop(struct message_queue *q, struct skynet_message *message) {
	int ret = 1;
	SPIN_LOCK(q)

	if (q->head != q->tail) {
		*message = q->queue[q->head++];
		ret = 0;
		int head = q->head;
		int tail = q->tail;
		int cap = q->cap;

		if (head >= cap) {
			q->head = head = 0;
		}
		int length = tail - head;
		if (length < 0) {
			length += cap;
		}
		while (length > q->overload_threshold) {
			q->overload = length;
			q->overload_threshold *= 2;
		}
	} else {
		// reset overload_threshold when queue is empty
		q->overload_threshold = MQ_OVERLOAD;
	}

	if (ret) {
		q->in_global = 0;
	}
	
	SPIN_UNLOCK(q)

	return ret;
}