nginx实现了自己的hash数据结构，正如数据结构中讲述的那样，nginx用开放链表法解决冲突，不过不同的是一旦一个hash表被初始化后就不会被修改，即插入和删除，只进行查询操作，所以nginx通过计算初始化时key的个数来确定hash表中桶的个数和每个桶的容量，这样能最大限度的利用内存资源。虽然用开放链表法，实际上每个桶都是一块连续的内存空间。nginx实现了两类hash结构，一类是key中包含通配符的ngx_hash_wildcard_t，另一类则是key中不包含通配符的ngx_hash_t，这里的通配符指*号。之所以会有这两类hash，是因为nginx主要用hash来存放url与ip的对应关系，目的是为了通过url来查找ip，而url是可以用通配符表示的，如*.baidu.com。接下来先通过深入到nginx源码中看看hash中定义的数据结构，然后看看两类hash是怎样实现的，最后通过一个例子来使用这两类hash。
1 相关的数据结构
1.1 ngx_hash_t结构
这类hash的数据结构定义如下：
1 typedef struct {
2 void *value; //ip，也就是<key,value>中的key
3 u_short len; //url长度
4 u_char name[1]; //url，也就是<key,value>中的value
5 } ngx_hash_elt_t;
6
7
8 typedef struct {
9 ngx_hash_elt_t **buckets; //每个桶的起始地址
10 ngx_uint_t size; //桶的个数
11 } ngx_hash_t;ngx_hash_t结构管理这个hash，ngx_hash_elt_t是hash桶中一个元素的表示。ngx_hash_elt_t字段中的value既可以指向实际的ip，也可以指向另一个hash表（这种情况只能出现在包含通配符的hash中），name字段既可以指向完整的url，也可以指向url的一部分（这种情况也只能出现在包含通配符的hash中）。
1.2 ngx_hash_wildcard_t
这个结构主要用于包含通配符的hash的，具体如下：
1 typedef struct {
2 ngx_hash_t hash;
3 void *value;
4 } ngx_hash_wildcard_t;这个结构相比ngx_hash_t结构就是多了一个value指针，value这个字段是用来存放某个已经达到末尾的通配符url对应的value值，如果通配符url没有达到末尾，这个字段为NULL。
1.3 ngx_hash_init_t
ngx_hash_init_t结构主要用于提供创建一个hash所需要的一些信息，定义如下：
1 typedef struct {
2 ngx_hash_t *hash; //指向待新建的hash表
3 ngx_hash_key_pt key; //hash函数指针
4
5 ngx_uint_t max_size; //hash表中桶的最大值,实际桶的个数存放在前面ngx_hash_t中的size字段中
6 ngx_uint_t bucket_size; //每个桶的最大尺寸
7
8 char *name; //hash表的名字，其实没啥用（在log中用）
9 ngx_pool_t *pool; //构建hash所用的内存池
10 ngx_pool_t *temp_pool; //构建hash所用的临时内存池
11 } ngx_hash_init_t;hash字段如果为NULL的话，会动态创建管理hash的结构ngx_hash_t，这种情况通常在包含通配符的情况下使用；如果不为NULL，则使用这个字段指向的ngx_hash_t结构，这种情况通常在不包含通配符的情况下使用。
1.4 ngx_hash_key_t
ngx_table_elt_t结构的数组来存放要插入到hash中的所有<key,value>对，所有初始化hash的函数都需要根据这样一个数组来初始化hash，这个在后面初始化hash函数的时候可以看到。
1 typedef struct {
2 ngx_str_t key; //<key,value>中的key
3 ngx_uint_t key_hash; //key通过hash函数算出的hash值
4 void *value; //<key,value>中的value
5 } ngx_hash_key_t;1.5 ngx_hash_combined_t
1 typedef struct {
2 ngx_hash_t hash;
3 ngx_hash_wildcard_t *wc_head;
4 ngx_hash_wildcard_t *wc_tail;
5 } ngx_hash_combined_t;这个结构包含了三类hash，hash字段表示不保护通配符的hash，wc_head字段表示包含前缀通配符的hash，wc_tail表示包含后缀通配符的hash。由于用户配置的url通常会是是不包含通配符的url，包含前缀通配符的url和包含后缀通配符的rul中的一种或多种，所以一般使用这个结构来完全表示用户配置的url。
1.6 ngx_hash_keys_arrays_t
1 typedef struct {
2 ngx_uint_t hsize;
3 ngx_pool_t *pool;
4 ngx_pool_t *temp_pool;
5
6 ngx_array_t keys; //存放不包含通配符的<key,value>键值对
7 ngx_array_t *keys_hash; //用来检测冲突的
8
9 ngx_array_t dns_wc_head; //存放包含前缀通配符的<key,value>键值对
10 ngx_array_t *dns_wc_head_hash; //用来检测冲突的
11
12 ngx_array_t dns_wc_tail; //存放包含后缀通配符的<key,value>键值对
13 ngx_array_t *dns_wc_tail_hash; //用来检测冲突的
14 } ngx_hash_keys_arrays_t;这个结构存放了初始化hash需要的所有键值对，keys数组用来初始化不包含通配符的hash，dns_wc_head数组用来初始化包含前缀通配符的hash，dns_wc_tail数组用来初始化包含后缀通配符的hash，并且dns_wc_head和dns_wc_tail数组包含的<key,value>键值对中的key都是已经去掉通配符的key，具体情况在后面ngx_hash_add_key函数的介绍中会详细说明。
2 相关函数
2.1 ngx_hash_init
这个函数用来初始化不包含通配符的hash，函数原型如下：
1 ngx_int_t
2 ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)hinit参数是初始化hash的相关信息，names存放了所有需要插入到hash中的<key,value>对，nelts是<key,value>对的个数。这个函数主要做了4部分的工作：
（1）检查bucket_size是否合法，也就是它的值必须保证一个桶至少能存放一个<key,value>键值对，具体如下：
1 #define NGX_HASH_ELT_SIZE(name) \
2 (sizeof(void *) + ngx_align((name)->key.len + 2, sizeof(void *)))
3
4 for (n = 0; n < nelts; n++) {
5 if (hinit->bucket_size < NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
6 {
7 ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
8 "could not build the %s, you should "
9 "increase %s_bucket_size: %i",
10 hinit->name, hinit->name, hinit->bucket_size);
11 return NGX_ERROR;
12 }
13 }上面的for循环保证hash的桶至少能装一个<key,value>键值对，宏NGX_HASH_ELT_SIZE用来计算一个ngx_hash_key_t表示一个实际的<key,value>键值对占用内存的大小，之所以NGX_HASH_ELT_SIZE(&names[n]) 后面需要加上sizeof(void *)，主要是每个桶都用一个值位NULL的void*指针来标记结束。
（2）计算hash中桶的个数
1 bucket_size = hinit->bucket_size - sizeof(void *); //除去桶标记后桶的大小
2 start = nelts / (bucket_size / (2 * sizeof(void *))); //桶的最小个数
3 start = start ? start : 1;
4 if (hinit->max_size > 10000 && nelts && hinit->max_size / nelts < 100) {
5 start = hinit->max_size - 1000;
6 }
7 //更新size来满足bucket_size
8 for (size = start; size < hinit->max_size; size++) {
9 ngx_memzero(test, size * sizeof(u_short));
10 for (n = 0; n < nelts; n++) {
11 if (names[n].key.data == NULL) {
12 continue;
13 }
14 key = names[n].key_hash % size; //计算当前<key,value>在哪个桶
15 test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n])); //计算当前<key,value>插入到桶之后桶的大小
16
17 if (test[key] > (u_short) bucket_size) { //检查桶是否溢出了
18 goto next;
19 }
20 }
21 goto found;
22 next:
23 continue;
24从最小桶的个数开始递增，直到所有的<key,value>键值对都能存放在对应的桶中不溢出，那当前的桶个数就是需要的桶个数。
（3）计算新创建的hash所占用的空间，并调用内存分配函数分配这些空间
1 for (i = 0; i < size; i++) {
2 test[i] = sizeof(void *);
3 }
4 //计算每个桶的实际大小
5 for (n = 0; n < nelts; n++) {
6 if (names[n].key.data == NULL) {
7 continue;
8 }
9
10 key = names[n].key_hash % size;
11 test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
12 }
13 //计算所有桶的大小
14 len = 0;
15
16 for (i = 0; i < size; i++) {
17 if (test[i] == sizeof(void *)) {
18 continue;
19 }
20
21 test[i] = (u_short) (ngx_align(test[i], ngx_cacheline_size)); //每个桶大小满足cache行对齐
22
23 len += test[i];
24 }上面根据实际的<key,value>键值对来实际计算每个桶的大小，而不是所有桶的大小的设置成一样的，这样能很有效的节约内存空间，当然由于每个桶的大小是不固定的，所有每个桶的末尾需要一个额外空间（大小为sizeof(void*)）来标记桶的结束。并且每个桶大小满足cache行对齐，这样能加快访问速度，从这里也可以看出nginx无处不在优化程序的性能和资源的使用效率。
1 if (hinit->hash == NULL) { //hash为NULL，则动态生成管理hash的结构
2 //calloc会把获取的内存初始化为0
3 hinit->hash = ngx_pcalloc(hinit->pool, sizeof(ngx_hash_wildcard_t)
4 + size * sizeof(ngx_hash_elt_t *));
5 if (hinit->hash == NULL) {
6 ngx_free(test);
7 return NGX_ERROR;
8 }
9
10 buckets = (ngx_hash_elt_t **)
11 ((u_char *) hinit->hash + sizeof(ngx_hash_wildcard_t));
12
13 } else {
14 buckets = ngx_pcalloc(hinit->pool, size * sizeof(ngx_hash_elt_t *));
15 if (buckets == NULL) {
16 ngx_free(test);
17 return NGX_ERROR;
18 }
19 }
20
21 elts = ngx_palloc(hinit->pool, len + ngx_cacheline_size); //将所有桶占用的空间分配在连续的内存空间中
22 if (elts == NULL) {
23 ngx_free(test);
24 return NGX_ERROR;
25 }
26
27 elts = ngx_align_ptr(elts, ngx_cacheline_size);
28
29 for (i = 0; i < size; i++) {
30 if (test[i] == sizeof(void *)) {
31 continue;
32 }
33
34 buckets[i] = (ngx_hash_elt_t *) elts; //初始化每个桶的起始位置
35 elts += test[i];
36
37 }上面代码先动态分配每个桶的起始指针，然后动态分配所有桶的空间，然后根据每个桶的大小，将每个桶的起始指针初始化指向对应桶的起始地址。
（4）将每个<key,value>键值对复制到所在的桶中
1 for (i = 0; i < size; i++) {
2 test[i] = 0;
3 }
4
5 for (n = 0; n < nelts; n++) {
6 if (names[n].key.data == NULL) {
7 continue;
8 }
9
10 key = names[n].key_hash % size; //计算当前<key,value>所在的桶
11 elt = (ngx_hash_elt_t *) ((u_char *) buckets[key] + test[key]); //计算当前<key,value>所在桶中的位置
12 //将当前<key,value>的值复制到桶中
13 elt->value = names[n].value;
14 elt->len = (u_short) names[n].key.len;
15
16 ngx_strlow(elt->name, names[n].key.data, names[n].key.len);
17 test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n])); //更新当前桶的大小
18 }
19 //为了标记每个桶的结束
20 for (i = 0; i < size; i++) {
21 if (buckets[i] == NULL) {
22 continue;
23 }
24
25 elt = (ngx_hash_elt_t *) ((u_char *) buckets[i] + test[i]);
26
27 elt->value = NULL; //前面每个test加上sizeof(void *)就是为了这个value指针
28 }通过调用ngx_hash_init函数，一个hash就建立起来了，该hash大概的情况如下图所示：
2.2 ngx_hash_add_key
1 ngx_int_t
2 ngx_hash_add_key(ngx_hash_keys_arrays_t *ha, ngx_str_t *key, void *value,
3 ngx_uint_t flags)ha中包含了三类ngx_hash_key_t类型的数组，分别用来初始化三类hash（介绍ngx_hash_keys_arrays_t时已说明），那么新的<key,value>应该加入到哪个数组中就是ngx_hash_add_key这个函数的主要任务。参数中的flags用来标记是否key中可能包含通配符，一般这个参数设置为NGX_HASH_WILDCARD_KEY，即可能包含通配符。需要注意的是这个函数会改变包含通配符的key，将通配符去掉，如*.baidu.com会改变为com.baidu.，.baidu.com会改变为com.baidu，www.baidu.*会改变为www.baidu，www.baidu.这种通配是不允许出现的。
2.3 ngx_hash_find
1 void *
2 ngx_hash_find(ngx_hash_t *hash, ngx_uint_t key, u_char *name, size_t len)这个函数通过给定的key和name在hash表中查找对应的<name,value>键值对，并将查找到的value值返回，参数中的key是name通过hash计算出来的。这个函数的实现很简单，就是通过key找到要查找的键值对在哪个桶中，然后遍历这个桶中的每个元素找key等于name的元素。
2.4 ngx_hash_wildcard_init
1 ngx_int_t
2 ngx_hash_wildcard_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,
3 ngx_uint_t nelts)这个函数是nginx实现通配hash的关键所在，该函数通过对通配键值对建立多级hash来实现通配hash。实现的hash表大致如下图所示：
上面的图只显示了二级hash，实际上可以由多级hash。下面我们举个实际的例子来加深理解，假设有下面这些键值对：
<*.com, "220.181.111.147">，<*.baidu.com, "220.181.111.147">，<*.baidu.com.cn, "220.181.111.147">，<*.google.com，"58.63.236.35">（1）通过函数ngx_hash_add_key将上面的键值对加入到ngx_hash_keys_arrays_t结构中的dns_wc_head数组中，该数组的值如下图所示：
{key = ("com." , 4 ), key_hash = 0 , value = "220.181.111.147"}
{key = ("cn.com.baidu." , 13), key_hash = 0 , value = "220.181.111.147"}
{key = ("com.baidu." , 10), key_hash = 0 , value = "220.181.111.147"}
{key = ("com.google." , 11), key_hash = 0 , value = "58.63.236.35"}（2）将上面的dns_wc_head数组传递给ngx_hash_wildcard_init，生成的hash如下图所示：
现在来看下ngx_hash_wildcard_init是怎样实现上面图所示的多级hash结构的。
1 for (n = 0; n < nelts; n = i) {
2
3 dot = 0;
4 //以.作为字段的分隔符
5 for (len = 0; len < names[n].key.len; len++) {
6 if (names[n].key.data[len] == '.') {
7 dot = 1;
8 break;
9 }
10 }
11
12 name = ngx_array_push(&curr_names);
13 if (name == NULL) {
14 return NGX_ERROR;
15 }
16 //将上面获取的字段作为当前hash的key
17 name->key.len = len;
18 name->key.data = names[n].key.data;
19 name->key_hash = hinit->key(name->key.data, name->key.len);
20 name->value = names[n].value;
21
22 dot_len = len + 1;
23
24 if (dot) {
25 len++;
26 }
27 //收集同一前缀的所有后缀
28 next_names.nelts = 0;
29
30 if (names[n].key.len != len) {
31 next_name = ngx_array_push(&next_names);
32 if (next_name == NULL) {
33 return NGX_ERROR;
34 }
35
36 next_name->key.len = names[n].key.len - len;
37 next_name->key.data = names[n].key.data + len;
38 next_name->key_hash = 0;
39 next_name->value = names[n].value;
40 }
41
42 for (i = n + 1; i < nelts; i++) {
43 if (ngx_strncmp(names[n].key.data, names[i].key.data, len) != 0) {
44 break;
45 }
46
47 if (!dot
48 && names[i].key.len > len
49 && names[i].key.data[len] != '.')
50 {
51 break;
52 }
53
54 next_name = ngx_array_push(&next_names);
55 if (next_name == NULL) {
56 return NGX_ERROR;
57 }
58
59 next_name->key.len = names[i].key.len - dot_len;
60 next_name->key.data = names[i].key.data + dot_len;
61 next_name->key_hash = 0;
62 next_name->value = names[i].value;
63 }
64
65 if (next_names.nelts) { //next_names中有元素
66
67 h = *hinit;
68 h.hash = NULL;
69 //递归建立当前字段的所有后缀字段组成的hash
70 if (ngx_hash_wildcard_init(&h, (ngx_hash_key_t *) next_names.elts,
71 next_names.nelts)
72 != NGX_OK)
73 {
74 return NGX_ERROR;
75 }
76
77 wdc = (ngx_hash_wildcard_t *) h.hash;
78
79 if (names[n].key.len == len) { //当前字段已经达到末尾
80 wdc->value = names[n].value;
81 }
82 //将后缀组成的下一级hash地址作为当前字段的value保存下来
83 name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2)); //2只有在后缀通配符的情况下才会出现
84
85 } else if (dot) { //只有一个，而且不是后缀通配符
86 name->value = (void *) ((uintptr_t) name->value | 1);
87 }
88 }
89 //根据<当前字段,value>键值对建立hash
90 if (ngx_hash_init(hinit, (ngx_hash_key_t *) curr_names.elts,
91 curr_names.nelts)
92 != NGX_OK)
93 {
94 return NGX_ERROR;
95 }
96
97 return NGX_OK;
98 }怎样标记一个键值对<key,value>中的value是指向实际的value，还是指向下一级的hash地址，这是上面代码实现的一个巧妙的地方。由于每个hash表的地址或者实际value的地址都是以4字节对齐的，所以这些地址的低2位都是0，这样通过这两位的标记可以很好地解决这个问题。
2.5 ngx_hash_find_wc_head
1 void *
2 ngx_hash_find_wc_head(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)这个函数根据name在前缀通配符hash中查找对应的value值。有了hash表后，查找是件相对更容易的事，从后往前的获取name的每个字段（根据.分割），用每个字段查hash表，如果获取的value值的标记存在下一级hash，则用同样的方法查下一个字段对应的hash表，就这样直到查到的value为真实的值为止。另一个通配符查找函数ngx_hash_find_wc_tail这是同样的原理，不同的是对name从前往后处理每个字段而已。
3 测试
测试的程序主要是使用nginx实现的数据结构和函数，先通过下列url和ip建立hash，然后对给定的url查找ip。
（1）测试的数据如下：
1 static ngx_str_t urls[Max_Num] = {
2 ngx_string("*.com"), //220.181.111.147
3 ngx_string("*.baidu.com.cn"),
4 ngx_string("*.baidu.com"),
5 ngx_string(".baidu.com"),
6 ngx_string("*.google.com"),
7 ngx_string("www.sina.com.cn"), //58.63.236.35
8 ngx_string("www.google.com"), //74.125.71.105
9 ngx_string("www.qq.com"), //60.28.14.190
10 ngx_string("www.163.com"), //123.103.14.237
11 ngx_string("www.sohu.com"), //219.234.82.50
12 ngx_string("abo321.org"), //117.40.196.26
13 ngx_string(".abo321.org"), //117.40.196.26
14 ngx_string("www.abo321.*") //117.40.196.26
15 };
16
17 static ngx_str_t values[Max_Num] = {
18 ngx_string("220.181.111.147"),
19 ngx_string("220.181.111.147"),
20 ngx_string("220.181.111.147"),
21 ngx_string("220.181.111.147"),
22 ngx_string("220.181.111.147"),
23 ngx_string("58.63.236.35"),
24 ngx_string("74.125.71.105"),
25 ngx_string("60.28.14.190"),
26 ngx_string("123.103.14.237"),
27 ngx_string("219.234.82.50"),
28 ngx_string("117.40.196.26"),
29 ngx_string("117.40.196.26"),
30 ngx_string("117.40.196.26")
31 };（2）测试代码为：https://github.com/cc1989/nginx_report/tree/master/nginx_test/hash
（3）测试结果
1 --------------------------------
2 create a new pool:
3 --------------------------------
4 pool = 0x810d020
5 .d
6 .last = 0x810d048
7 .end = 0x810d420
8 .next = (nil)
9 .failed = 0
10 .max = 984
11 .current = 0x810d020
12 .chain = (nil)
13 .large = (nil)
14 .cleanup = (nil)
15 .log = 0x8051518
16 available pool memory = 984
17
18 --------------------------------
19 create and add urls to it:
20 --------------------------------
21 array = 0xbfed53b4
22 .elts = 0xb7542008
23 .nelts = 6
24 .size = 16
25 .nalloc = 16384
26 .pool = 0x810d450
27 elements:
28 0xb7542008: {key = ("www.sina.com.cn", 15), key_hash = 1528635686 , value = "58.63.236.35" }
29 0xb7542018: {key = ("www.google.com" , 14), key_hash = -702889725 , value = "74.125.71.105" }
30 0xb7542028: {key = ("www.qq.com" , 10), key_hash = 203430122 , value = "60.28.14.190" }
31 0xb7542038: {key = ("www.163.com" , 11), key_hash = -640386838 , value = "123.103.14.237" }
32 0xb7542048: {key = ("www.sohu.com" , 12), key_hash = 1313636595 , value = "219.234.82.50" }
33 0xb7542058: {key = ("abo321.org" , 10), key_hash = 1050805370 , value = "117.40.196.26" }
34
35 array = 0xbfed53cc
36 .elts = 0xb7501008
37 .nelts = 4
38 .size = 16
39 .nalloc = 16384
40 .pool = 0x810d450
41 elements:
42 0xb7501008: {key = ("com." , 4 ), key_hash = 0 , value = "220.181.111.147"}
43 0xb7501018: {key = ("cn.com.baidu." , 13), key_hash = 0 , value = "220.181.111.147"}
44 0xb7501028: {key = ("com.baidu." , 10), key_hash = 0 , value = "220.181.111.147"}
45 0xb7501038: {key = ("com.google." , 11), key_hash = 0 , value = "220.181.111.147"}
46
47 array = 0xbfed53e4
48 .elts = 0xb74c0008
49 .nelts = 1
50 .size = 16
51 .nalloc = 16384
52 .pool = 0x810d450
53 elements:
54 0xb74c0008: {key = ("www.abo321" , 10), key_hash = 0 , value = "117.40.196.26" }
55
56 --------------------------------
57 the pool:
58 --------------------------------
59 pool = 0x810d020
60 .d
61 .last = 0x810d2a9
62 .end = 0x810d420
63 .next = (nil)
64 .failed = 0
65 .max = 984
66 .current = 0x810d020
67 .chain = (nil)
68 .large = (nil)
69 .cleanup = (nil)
70 .log = 0x8051518
71 available pool memory = 375
72
73 array = 0xbfed53cc
74 .elts = 0xb7501008
75 .nelts = 4
76 .size = 16
77 .nalloc = 16384
78 .pool = 0x810d450
79 elements:
80 0xb7501008: {key = ("cn.com.baidu." , 13), key_hash = 0 , value = "220.181.111.147"}
81 0xb7501018: {key = ("com." , 4 ), key_hash = 0 , value = "220.181.111.147"}
82 0xb7501028: {key = ("com.baidu." , 10), key_hash = 0 , value = "220.181.111.147"}
83 0xb7501038: {key = ("com.google." , 11), key_hash = 0 , value = "220.181.111.147"}
84
85 array = 0xbfed53e4
86 .elts = 0xb74c0008
87 .nelts = 1
88 .size = 16
89 .nalloc = 16384
90 .pool = 0x810d450
91 elements:
92 0xb74c0008: {key = ("www.abo321" , 10), key_hash = 0 , value = "117.40.196.26" }
93
94 --------------------------------
95 the hash:
96 --------------------------------
97 hash = 0xbfed53fc: **buckets = 0x810d2ac, size = 3
98 0x810d2ac: buckets[0] = 0x810d2c0
99 0x810d2b0: buckets[1] = 0x810d300
100 0x810d2b4: buckets[2] = 0x810d320
101
102 key 1528635686: buckets 2: 0x810d320: {value = "58.63.236.35" , len = 15, name = "www.sina.com.cn"}
103 key -702889725: buckets 1: 0x810d300: {value = "74.125.71.105" , len = 14, name = "www.google.com" }
104 key 203430122 : buckets 2: 0x810d338: {value = "60.28.14.190" , len = 10, name = "www.qq.com" }
105 key -640386838: buckets 0: 0x810d2c0: {value = "123.103.14.237" , len = 11, name = "www.163.com" }
106 key 1313636595: buckets 0: 0x810d2d4: {value = "219.234.82.50" , len = 12, name = "www.sohu.com" }
107 key 1050805370: buckets 2: 0x810d348: {value = "117.40.196.26" , len = 10, name = "abo321.org" }
108 value = NULL
109 hash = 0x8111cd0: **buckets = 0x8111cdc, size = 1
110 0x8111cdc: buckets[0] = 0x8111ce0
111 buckets 0: 0x8111ce0: {value = "0x810d3c8 ", len = 2, name = "cn" }
112 value = NULL
113 hash = 0x810d3c8: **buckets = 0x810d3d4, size = 1
114 0x810d3d4: buckets[0] = 0x810d3e0
115 buckets 0: 0x810d3e0: {value = "0x810d378 ", len = 3, name = "com" }
116 value = NULL
117 hash = 0x810d378: **buckets = 0x810d384, size = 1
118 0x810d384: buckets[0] = 0x810d3a0
119 buckets 0: 0x810d3a0 {value = "220.181.111.147", len = 5, name = "baidu" }
120 buckets 0: 0x8111ce8: {value = "0x8111c80 ", len = 3, name = "com" }
121 value = "220.181.111.147"
122 hash = 0x8111c80: **buckets = 0x8111c8c, size = 1
123 0x8111c8c: buckets[0] = 0x8111ca0
124 buckets 0: 0x8111ca0 {value = "220.181.111.147", len = 5, name = "baidu" }
125 buckets 0: 0x8111cac {value = "220.181.111.147", len = 6, name = "google" }
126 value = NULL
127 hash = 0x8111d70: **buckets = 0x8111d7c, size = 1
128 0x8111d7c: buckets[0] = 0x8111d80
129 buckets 0: 0x8111d80: {value = "0x8111d20 ", len = 3, name = "www" }
130 value = NULL
131 hash = 0x8111d20: **buckets = 0x8111d2c, size = 1
132 0x8111d2c: buckets[0] = 0x8111d40
133 buckets 0: 0x8111d40 {value = "117.40.196.26" , len = 6, name = "abo321" }
134
135 --------------------------------
136 the pool:
137 --------------------------------
138 pool = 0x810d020
139 .d
140 .last = 0x810d418
141 .end = 0x810d420
142 .next = 0x8111c70
143 .failed = 0
144 .max = 984
145 .current = 0x810d020
146 .chain = (nil)
147 .large = (nil)
148 .cleanup = (nil)
149 .log = 0x8051518
150 available pool memory = 8
151
152 pool = 0x8111c70
153 .d
154 .last = 0x8111dc0
155 .end = 0x8112070
156 .next = (nil)
157 .failed = 0
158 .max = 135339148
159 .current = 0x1
160 .chain = 0x810d0d8
161 .large = 0x8111ca0
162 .cleanup = (nil)
163 .log = (nil)
164 available pool memory = 688
165
166 --------------------------------
167 find test:
168 --------------------------------
169 (url = "*.com" , key = 40256957 ) found, (ip = "220.181.111.147")
170 (url = "*.baidu.com.cn" , key = 234385007 ) found, (ip = "220.181.111.147")
171 (url = "*.baidu.com" , key = -724157846 ) found, (ip = "220.181.111.147")
172 (url = ".baidu.com" , key = 1733355200 ) found, (ip = "220.181.111.147")
173 (url = "*.google.com" , key = -1465170800) found, (ip = "220.181.111.147")
174 (url = "www.sina.com.cn", key = 1528635686 ) found, (ip = "58.63.236.35 ")
175 (url = "www.google.com" , key = -702889725 ) found, (ip = "74.125.71.105 ")
176 (url = "www.qq.com" , key = 203430122 ) found, (ip = "60.28.14.190 ")
177 (url = "www.163.com" , key = -640386838 ) found, (ip = "123.103.14.237 ")
178 (url = "www.sohu.com" , key = 1313636595 ) found, (ip = "219.234.82.50 ")
179 (url = "abo321.org" , key = 1050805370 ) found, (ip = "117.40.196.26 ")
180 (url = ".abo321.org" , key = -4578520 ) not found!
181 (url = "www.abo321.*" , key = 1494696375 ) found, (ip = "117.40.196.26 ")
182
183 (url = "*.xx.xx" , key = 51835370 ) not found!
184 (url = "www.baidu.com" , key = 270263191 ) found, (ip = "220.181.111.147")
185 (url = "www.baidu." , key = -239024726 ) not found!
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
