关于互斥量《APUE》

blackgenius

CU的高手们，请指教一下APUE里面的一段关于互斥量的程序，本人菜鸟，无法理解，请求指点：
其中有两句，真不知道什么意思，
fp->f_next = fh[idx];
fh[idx] = fp->f_next;
请指点迷津

1. #include <stdlib.h>
   
2. #include <pthread.h>
   
3. 
   
4. #define NHASH 29
   
5. #define HASH(fp) (((unsigned long)fp)%NHASH)
   
6. 
   
7. struct foo *fh[NHASH];
   
8. 
   
9. pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
   
10. 
    
11. struct foo {
    
12.         int             f_count;
    
13.         pthread_mutex_t f_lock;
    
14.         struct foo     *f_next; /* protected by hashlock */
    
15.         int             f_id;
    
16.         /* ... more stuff here ... */
    
17. };
    
18. 
    
19. struct foo *
    
20. foo_alloc(void) /* allocate the object */
    
21. {
    
22.         struct foo      *fp;
    
23.         int                     idx;
    
24. 
    
25.         if ((fp = malloc(sizeof(struct foo))) != NULL) {
    
26.                 fp->f_count = 1;
    
27.                 if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
    
28.                         free(fp);
    
29.                         return(NULL);
    
30.                 }
    
31.                 idx = HASH(fp);
    
32.                 pthread_mutex_lock(&hashlock);
    
33.                 fp->f_next = fh[idx];
    
34.                 fh[idx] = fp->f_next;
    
35.                 pthread_mutex_lock(&fp->f_lock);
    
36.                 pthread_mutex_unlock(&hashlock);
    
37.                 /* ... continue initialization ... */
    
38.                 pthread_mutex_unlock(&fp->f_lock);
    
39.         }
    
40. return(fp);
    
41. }
    
42. 
    
43. void
    
44. foo_hold(struct foo *fp) /* add a reference to the object */
    
45. {
    
46.         pthread_mutex_lock(&fp->f_lock);
    
47.         fp->f_count++;
    
48.         pthread_mutex_unlock(&fp->f_lock);
    
49. }
    
50. 
    
51. struct foo *
    
52. foo_find(int id) /* find an existing object */
    
53. {
    
54.         struct foo      *fp;
    
55.         int                     idx;
    
56. 
    
57.         idx = HASH(fp);
    
58.         pthread_mutex_lock(&hashlock);
    
59.         for (fp = fh[idx]; fp != NULL; fp = fp->f_next) {
    
60.                 if (fp->f_id == id) {
    
61.                         foo_hold(fp);
    
62.                         break;
    
63.                 }
    
64.         }
    
65.         pthread_mutex_unlock(&hashlock);
    
66.         return(fp);
    
67. }
    
68. 
    
69. void
    
70. foo_rele(struct foo *fp) /* release a reference to the object */
    
71. {
    
72.         struct foo      *tfp;
    
73.         int                     idx;
    
74. 
    
75.         pthread_mutex_lock(&fp->f_lock);
    
76.         if (fp->f_count == 1) { /* last reference */
    
77.                 pthread_mutex_unlock(&fp->f_lock);
    
78.                 pthread_mutex_lock(&hashlock);
    
79. pthread_mutex_lock(&fp->f_lock);
    
80.                 /* need to recheck the condition */
    
81.                 if (fp->f_count != 1) {
    
82.                         fp->f_count--;
    
83.                         pthread_mutex_unlock(&fp->f_lock);
    
84.                         pthread_mutex_unlock(&hashlock);
    
85.                         return;
    
86.                 }
    
87.                 /* remove from list */
    
88.                 idx = HASH(fp);
    
89.                 tfp = fh[idx];
    
90.                 if (tfp == fp) {
    
91.                         fh[idx] = fp->f_next;
    
92.                 } else {
    
93.                         while (tfp->f_next != fp)
    
94.                                 tfp = tfp->f_next;
    
95.                         tfp->f_next = fp->f_next;
    
96.                 }
    
97.                 pthread_mutex_unlock(&hashlock);
    
98.                 pthread_mutex_unlock(&fp->f_lock);
    
99.                 pthread_mutex_destroy(&fp->f_lock);
    
100.                 free(fp);
     
101.         } else {
     
102.                 fp->f_count--;
     
103.                 pthread_mutex_unlock(&fp->f_lock);
     
104.         }
     
105. }
     
106.                                                                                                                                            105,1        底端
     

复制代码

liwangli1983

fp->f_next = fh[idx];
fh[idx] = fp->f_next;
这个写错了,应为:
fp->f_next = fh[idx];
fh[idx] = fp;

另外,find那个算法也错了

blackgenius

回复 2# liwangli1983
谢谢指点啊～我菜鸟一个，自己是没法发现这些错误的～

单眼皮大姐

回复 2# liwangli1983


    能帮忙解释下
           idx = HASH(fp);

                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);
这段代码是什么意思？谢谢啦啊

liwangli1983

回复  liwangli1983
谢谢指点啊～我菜鸟一个，自己是没法发现这些错误的～
blackgenius 发表于 2010-07-05 22:06

我看到这块是也很疑惑,后来找到了英文版的勘误表,查到了这两处.

liwangli1983

回复  liwangli1983


    能帮忙解释下
           idx = HASH(fp);

                pthread_mut ...
单眼皮大姐 发表于 2010-07-05 23:23

fh是一个散列表,每一项都是struct foo型指针,面这个指针正好是一个struct foo型链表的头结点.
fp->f_next = fh[idx];
fh[idx] = fp;
就是把一个新的项插到链表的头结点.

单眼皮大姐

回复 6# liwangli1983


    就这句： idx = HASH(fp);干嘛用fp的地址％29之后当做fh的索引项，直接定义一个指针不也能帮助把一个新结点加入到链表中吗？我当时看这的时候就有些疑问，后来一知半解的就过去了，这次希望弄清楚，麻烦这位朋友帮忙讲讲，谢谢了

liwangli1983

回复  liwangli1983


    就这句： idx = HASH(fp);干嘛用fp的地址％29之后当做fh的索引项，直接定义一 ...
单眼皮大姐 发表于 2010-07-06 09:56

GOOGLE一下散列表吧