读APUE分析散列表的使用

最近学习APUE读到避免线程死锁的部分，看到部分源码涉及到避免死锁部分，源码使用了散列表来实现对结构（struct）的存储与查找。

本文不讨论代码中的互斥量部分。

 #include <stdlib.h>
 #include <pthread.h>  

 #define NHASH 29
 #define HASH(id) (((unsigned long)id)%NHASH)  

 struct foo *fh[NHASH];  

 pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;  

 struct foo {
     int             f_count;
     pthread_mutex_t f_lock;
     int             f_id;
     struct foo     *f_next; /* protected by hashlock */
     /* ... more stuff here ... */
 };  

 struct foo *
 foo_alloc(int id) /* allocate the object */
 {
     struct foo  *fp;
     int         idx;  

     if ((fp = malloc(sizeof(struct foo))) != NULL) {
         fp->f_count = ;
         fp->f_id = id;
         if (pthread_mutex_init(&fp->f_lock, NULL) != ) {
             free(fp);
             return(NULL);
         }
         idx = HASH(id);
         pthread_mutex_lock(&hashlock);
         fp->f_next = fh[idx];
         fh[idx] = fp;
         pthread_mutex_lock(&fp->f_lock);
         pthread_mutex_unlock(&hashlock);
         /* ... continue initialization ... */
         pthread_mutex_unlock(&fp->f_lock);
     }
     return(fp);
 }  

 void
 foo_hold(struct foo *fp) /* add a reference to the object */
 {
     pthread_mutex_lock(&fp->f_lock);
     fp->f_count++;
     pthread_mutex_unlock(&fp->f_lock);
 }  

 struct foo *
 foo_find(int id) /* find an existing object */
 {
     struct foo  *fp;  

     pthread_mutex_lock(&hashlock);
     for (fp = fh[HASH(id)]; fp != NULL; fp = fp->f_next) {
         if (fp->f_id == id) {
             foo_hold(fp);
             break;
         }
     }
     pthread_mutex_unlock(&hashlock);
     return(fp);
 }  

 void
 foo_rele(struct foo *fp) /* release a reference to the object */
 {
     struct foo  *tfp;
     int         idx;  

     pthread_mutex_lock(&fp->f_lock);
     if (fp->f_count == ) { /* last reference */
         pthread_mutex_unlock(&fp->f_lock);
         pthread_mutex_lock(&hashlock);
         pthread_mutex_lock(&fp->f_lock);
         /* need to recheck the condition */
         if (fp->f_count != ) {
             fp->f_count--;
             pthread_mutex_unlock(&fp->f_lock);
             pthread_mutex_unlock(&hashlock);
             return;
         }
         /* remove from list */
         idx = HASH(fp->f_id);
         tfp = fh[idx];
         if (tfp == fp) {
             fh[idx] = fp->f_next;
         } else {
             while (tfp->f_next != fp)
                 tfp = tfp->f_next;
             tfp->f_next = fp->f_next;
         }
         pthread_mutex_unlock(&hashlock);
         pthread_mutex_unlock(&fp->f_lock);
         pthread_mutex_destroy(&fp->f_lock);
         free(fp);
     } else {
         fp->f_count--;
         pthread_mutex_unlock(&fp->f_lock);
     }
 }  

代码来自：http://blog.csdn.net/abcef31415926/article/details/53898325

---

取余法散列表：书中使用的是取余法来构建散列表，通过使用第5行定义的宏函数来计算（唯一计算）出每个ID（struct内部属性，保证struct唯一性）对应的散列表中的直接索引值。

而对于一个本例中已经构建出来的散列表，它的本质是这样的：

上图的0-15的实现实质其实也是指针（有自己指向的对象的Value值），这也是我之前没有弄明白的地方。

之前一直以为散列表是一个链表（就是里面存了，n个指针，每个指针相互首尾串联）。

然而不然，散列表的每个元素都是一个链表的头指针（即假设0-15都不为空，则一个散列表有16个相互独立的链表），添加新结构进入散列表的方法则是将结构本身代替索引位置的头指针，并指向他。

---

代码分析（背景灰色部分）：

4-5 ：使用求余的方法构建散列函数，使得每一个ID都能通过散列函数计算出的值落中在散列表定义数组的索引区间内。

7：定义一个符合上述条件区间长度的数组，数组内的每个元素都是struct foo *类型，初始值为NULL。

foo_alloc(int id)部分：该函数的作用是在散列表中添加一个未初始化的id为id的新结构。

32：计算散列表中的索引（计算应该将新结构放在第几个链表里）。

34：将该结构的next节点指向目前该位置上链表的头结点。

35：将链表的头结点设置成自己的指针。

foo_find(int id)部分：该函数的作用是通过结构的id，在散列表中找到结构的指针。

58：通过散列函数计算出数组的索引值，并确保在该索引位置上的链表中从头到尾使用循环查找。

59-63：如果链表中的某个结点满足id值和传入的id值相等的条件，就确信已经找到了该结构，返回这个指针。

foo_rele(struct foo *fp)部分：释放这个引用（指针），如果这是最后一个引用释放这个对象的内存空间。

75：如果这是当前的引用计数是1（该指针是最后一个指向对象的指针）。

87-88：通过散列函数计算索引，并获取链表第一个结点的地址。

89-91：如果当前结点是首结点，将链表的首指针（该位置的指针）设置为该元素的next指针。

92-95：向后寻找结点，直到该节点（结点a）的next是目标元素（结点b）的指针，把结点a的next设置为结点b的next。

99：该结点已经不在散列表内，释放对象的内存。