应用案例——高并发 WEB 服务器队列的应用

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

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

具体实现方案：

1. 使用双向循环队列保存缓存的文件节点，这样可以实现多种淘汰策略：

比如：如果采用淘汰进入时间比较久的策略，就可以使用队列的特性，先进先出

如果要采用按照 LRU，就遍历链表，找到节点删除。

源码实现：

nginx_queue.h

 1 #ifndef _NGX_QUEUE_H_INCLUDED_

 2 #define _NGX_QUEUE_H_INCLUDED_

 3 typedef struct ngx_queue_s ngx_queue_t;

 4

 5 struct ngx_queue_s

 6 {

 7     ngx_queue_t* prev;

 8     ngx_queue_t* next;

 9 };

10

11 #define ngx_queue_init(q)    　　 \

12     (q)->prev = q;            　　\

13 (q)->next = q

14 #define ngx_queue_empty(h)   　　 \

15 (h == (h)->prev)

16 #define ngx_queue_insert_head(h, x)\

17     (x)->next = (h)->next;　　　　　\

18     (x)->next->prev = x;　　　　　　\

19     (x)->prev = h;　　　　　　　　　 \

20 (h)->next = x

21 #define ngx_queue_insert_after    ngx_queue_insert_head

22 #define ngx_queue_insert_tail(h, x)\

23     (x)->prev = (h)->prev;　　　　　 \

24     (x)->prev->next = x;　　　　　　 \

25     (x)->next = h;　　　　　　　　　　\

26 (h)->prev = x

27 #define ngx_queue_head(h)            \

28 (h)->next

29 #define ngx_queue_last(h)            \

30 (h)->prev

31 #define ngx_queue_sentinel(h)        \

32 (h)

33 #define ngx_queue_next(q)            \

34 (q)->next

35 #define ngx_queue_prev(q)            \

36 (q)->prev

37 #define ngx_queue_remove(x)          \

38 (x)->next->prev = (x)->prev;         \

39 (x)->prev->next = (x)->next

40 #define ngx_queue_data(q, type, link)

41 (type*)((char*)q - offsetof(type, link))

42 #endif

Nginx_双向循环队列.cpp

 1 #include <Windows.h>

 2 #include <stdlib.h>

 3 #include <iostream>

 4 #include "nginx_queue.h"

 5 #include <time.h>

 6

 7 using namespace std;

 8

 9 typedef struct ngx_cached_open_file_s

10 {

11     //其它属性省略...

12     int fd;

13     ngx_queue_t    queue;

14 }ngx_cached_file_t;

15

16 typedef struct

17 {

18     //其它属性省略...

19     ngx_queue_t    expire_queue;

20     //其它属性省略...

21 } ngx_open_file_cache_t;

22

23 int main(void)

24 {

25     ngx_open_file_cache_t* cache = new ngx_open_file_cache_t;

26     ngx_queue_t* q;

27     ngx_queue_init(&cache->expire_queue);

28

29     //1. 模拟文件模块，增加打开的文件到缓存中

30     for (int i = 0; i < 10; i++)

31     {

32         ngx_cached_file_t* e = new ngx_cached_file_t;

33         e->fd = i;

34         ngx_queue_insert_head(&cache->expire_queue, &e->queue);

35     }

36

37     //遍历队列

38     for (q = cache->expire_queue.next;q != ngx_queue_sentinel(&cache->expire_queue); q = q->next)

39     {

40         printf("队列中的元素：%d\n", (ngx_queue_data(q, ngx_cached_file_t, queue))->fd);

41     }

42

43     //模拟缓存的文件到期，执行出列操作

44     while (!ngx_queue_empty(&cache->expire_queue))

45     {

46         q = ngx_queue_last(&cache->expire_queue);

47         ngx_cached_file_t* cached_file = ngx_queue_data(q, ngx_cached_file_t, queue);

48         printf("出队列中的元素：%d\n", cached_file->fd);

49         ngx_queue_remove(q);

50         delete(cached_file);

51     }

52     system("pause");

53     return 0;

54 }

==================================================================================================================

巴特西

应用案例——高并发 WEB 服务器队列的应用

具体实现方案：

源码实现：

最新文章

热门文章