破“队”式（二）

循环队列

在队列的顺序存储中，采用出队方式 2, 删除 front 所指的元素，然后加 1 并返回被删元素。这样可以避免元素 移动，但是也带来了一个新的问题“假溢出”。

优先队列

它的入队顺序没有变化，但是出队的顺序是根据优先级的高低来决定的。优先级高的 优先出队。

typedef int DataType; //队列中元素类型 

typedef struct _QNode { //结点结构 
	int priority; //每个节点的优先级,9 最高优先级，0 最低优先级，优先级相同， 取第一个节点 
	DataType data; 
	struct _QNode *next; 
}QNode;

typedef QNode * QueuePtr; 

typedef struct Queue { 
	int length; //队列的长度 
	QueuePtr front; //队头指针 
	QueuePtr rear; //队尾指针 
}LinkQueue;

//出队，遍历队列，找到队列中优先级最高的元素 data 出队 
int DeleteQueue(LinkQueue *LQ, DataType *data){ 
	QNode **prev = NULL, *prev_node=NULL;//保存当前已选举的最高优先级节点和上一个节点的指针地址。  
	QNode *last = NULL, *tmp = NULL; 

	if(!LQ || IsEmpty(LQ)){ 
		cout<<"队列为空！"<<endl; 
		return 0; 
	}

	if(!data) return 0; 

	//prev 指向队头 front 指针的地址 
	prev = &(LQ->front); 
	printf("第一个节点的优先级: %d\n", (*prev)->priority); 

	last = LQ->front; 
	tmp = last->next; 

	while(tmp){ 
		if(tmp->priority >(*prev)->priority){ 
			printf("抓到个更大优先级的节点[priority: %d]\n", tmp->priority); 
			prev = &(last->next); 
			prev_node= last; 
		}
		last=tmp; 
		tmp=tmp->next; 
	}

	*data = (*prev)->data; 
	tmp = *prev; 
	(*prev) = (*prev)->next; 
	delete tmp; 
	LQ->length--; 

//接下来存在 2 种情况需要分别对待 
//1.删除的是首节点,而且队列长度为零 
	if(LQ->length==0){ 
		LQ->rear=NULL; 
	}

//2.删除的是尾部节点 
	if(prev_node&&prev_node->next==NULL){ 
		LQ->rear=prev_node; 
	}
	return 1; 
}

 

WEB 服务器队列的应用

在高并发 HTTP 反向代理服务器 Nginx 中，存在着一个跟性能息息相关的模块 - 文件缓存。

经常访问到的文件会被 nginx 从磁盘缓存到内存，这样可以极大的提高 Nginx 的并发能力，不过因为 内存的限制，当缓存的文件数达到一定程度的时候就会采取淘汰机制，优先淘汰进入时间比较久或是最近 访问很少(LRU)的队列文件。

nginx_queue.h

#ifndef _NGX_QUEUE_H_INCLUDED_ 
#define _NGX_QUEUE_H_INCLUDED_ 

typedef struct ngx_queue_s ngx_queue_t; 

struct ngx_queue_s { 
	ngx_queue_t *prev; 
	ngx_queue_t *next; 
};

#define ngx_queue_init(q) \ 
	(q)->prev = q; \ 
	(q)->next = q 

#define ngx_queue_empty(h) \ 
	(h == (h)->prev) 

#define ngx_queue_insert_head(h, x) \ 
	(x)->next = (h)->next; \ 
	(x)->next->prev = x; \ 
	(x)->prev = h; \ 
	(h)->next = x 

#define ngx_queue_insert_after ngx_queue_insert_head 

#define ngx_queue_insert_tail(h, x) \ 
	(x)->prev = (h)->prev; \ 
	(x)->prev->next = x; \ 
	(x)->next = h; \ 
	(h)->prev = x 

#define ngx_queue_head(h) \ 
	(h)->next 

#define ngx_queue_last(h) \ 
	(h)->prev

#define ngx_queue_sentinel(h) \ 
	(h) 

#define ngx_queue_next(q) \ 
	(q)->next 

#define ngx_queue_prev(q) \ 
	(q)->prev 

#define ngx_queue_remove(x) \ 
	(x)->next->prev = (x)->prev; \ 
	(x)->prev->next = (x)->next 

#define ngx_queue_data(q, type, link) \ 
	(type *) ((char *) q - offsetof(type, link)) 

#endif

Nginx_双向循环队列.cpp

#include <Windows.h> 
#include <stdlib.h> 
#include <iostream> 
#include "nginx_queue.h" 
#include <time.h> 

using namespace std; 

typedef struct ngx_cached_open_file_s { //其它属性省略... 
	int fd; 
	ngx_queue_t queue; 
}ngx_cached_file_t;

typedef struct { 
	//其它属性省略... 
	ngx_queue_t expire_queue; 
	//其它属性省略... 
} ngx_open_file_cache_t; 

int main(void){ 
	ngx_open_file_cache_t *cache = new ngx_open_file_cache_t;
	ngx_queue_t *q; 
	
	ngx_queue_init(&cache->expire_queue); 

	//1. 模拟文件模块，增加打开的文件到缓存中 
	for(int i=0; i<10; i++){ 
		ngx_cached_file_t *e = new ngx_cached_file_t; 
		e->fd = i; 
		ngx_queue_insert_head(&cache->expire_queue, &e->queue); 
	}

	//遍历队列 
	for(q=cache->expire_queue.next; q!=ngx_queue_sentinel(&cache->expire_queue); q=q->next){ 
		printf("队列中的元素：%d\n", (ngx_queue_data(q, ngx_cached_file_t, queue))->fd); 
	}

	//模拟缓存的文件到期，执行出列操作
	while(!ngx_queue_empty(&cache->expire_queue)){ 
		q=ngx_queue_last(&cache->expire_queue); 
		ngx_cached_file_t *cached_file = ngx_queue_data(q, ngx_cached_file_t, queue); 
		printf("出队列中的元素：%d\n", cached_file->fd); 
		ngx_queue_remove(q); 
		delete(cached_file); 
	}
	
	system("pause"); 
	return 0; 
}