~请教：apue 互斥量foo_find例子不解，望指点

apueunix

先谢谢，
apue 互斥量foo_find例子不解,对f_id查询前为什么结构数据不加锁（下面红色部分）？如果其它线程直接修改f_id的话,f_id 数据就不致；还是说f_id是不会修改的，但是从结构数据的保护上也要控制吧；

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

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

struct foo *fh[NHASH];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;

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

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

    if ((fp = malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        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 ... */
    }
    return(fp);

}

struct foo *fp
foo_find( int id)
{
       struct  foo *fp;
       int idx;
       idx = HASH(fp);
       pthread_mutex_lock(&hashlock);
       for ( fp=fp[idx]; fp !=NULL;fp=fp[idx]->f_next)
       {
          if (fp ->f_id == id)
           {
              fp->f_count++;
              break;
            }
         }
        pthread_mutex_unlock(&hashlock);
        return (fp);
   ｝
................. 后续省略

solu

没看到  pthread_mutex_lock(&hashlock); ？

apueunix

回复 2# solu
谢谢回复。

hashlock 是表的锁，不是数据的锁，apue例中的数据锁是f_lock，本例中f_lock并没有上锁处理。


   

apueunix

望高手能解释下，我遇到的问题，为什么查询时不对数据加锁。


   

tseesing

假设可以更改，可能有个临界点：
foo_find()  中

1. 59     for (fp = fh[idx]; fp != NULL; fp = fp->f_next) {
   
2. 60         if (fp->f_id == id) {
   
3. 61             foo_hold(fp); // 比较 id 相等了，另一线程先于此函数，将 f_id 改了，那么这里操作的就不再是等 id.的那个元素了；
   
4.                               //  但如果修改的修改 f_id 的线程也是持 hashlock 的话，就没问题。
   
5. 62             break;
   
6. 63         }
   
7. 64     }

复制代码

假设不可更改，那么必须要在初始化 foo_alloc() 时设置 f_id 完成：
也有个临界点：

1. 31         idx = HASH(fp);
   
2. 32         pthread_mutex_lock(&hashlock);
   
3. 33         fp->f_next = fh[idx];
   
4. 34         fh[idx] = fp->f_next;
   
5. 35         pthread_mutex_lock(&fp->f_lock);
   
6. 36         pthread_mutex_unlock(&hashlock);
   
7. 37         /* ... continue initialization ... */
   
8. 38         pthread_mutex_unlock(&fp->f_lock);

复制代码

f_id 还未初始化， 就加入 fh[] 数组中了，若是会在 37 行中省略的代码中初始化 f_id， 那 L36 就解了 hashlock 的锁，
如果另外线程此时在 foo_find() 中 pthread_mutex_lock(&hashlock) ，上边 L36 一解锁， 就进入遍历，
又恰好在 foo_alloc() 初始化 fp->f_id 之前使用新加入的节点 fp->f_id 字段时， 就悲剧了。。
愚见， 同等高人

apueunix

tseesing 发表于 2013-10-01 17:07
假设可以更改，可能有个临界点：
foo_find()  中假设不可更改，那么必须要在初始化 foo_alloc() 时设置 f_ ...

谢谢你的回复！
你提到的两种情况，我想都用f_lock mutex_lock来获得处理权的，不会有临界问题；还有hashlock不是用来处理内部数据的，除了跟链表相关的数据；

我不解的是APUE中foo_find 的例子(红色部分）是不是缺少f_lock控制，这样如何保持数据的一致性？

pirloofmilan

我也觉得有问题，另外，查找逻辑似乎也有问题，我觉得应该遍历fh，找到与参数id匹配的foo返回，例子程序里面直接对fp对HASH（如下），这个时候的fp只是一个随机值，拿他做HASH有意义么，高手指教！

1. 
   
2. struct foo *fp
   
3. foo_find( int id)
   
4. {
   
5.        struct  foo *fp;
   
6.        int idx;
   
7.       [color=Red] idx = HASH(fp);[/color]
   
8.        pthread_mutex_lock(&hashlock);
   
9.        for ( fp=fp[idx]; fp !=NULL;fp=fp[idx]->f_next)
   
10.        {
    
11.           if (fp ->f_id == id)
    
12.            {
    
13.               fp->f_count++;
    
14.               break;
    
15.             }
    
16.          }
    
17.         pthread_mutex_unlock(&hashlock);
    
18.         return (fp);
    
19.    ｝
    

复制代码

pirloofmilan

find逻辑的问题找到答案了：http://www.apuebook.com/errata2e.html
Page 374, end of page. In the statement idx = HASH(fp) at the beginning of foo_find, fp is undefined at this point. The correct thing to do is to search every hash chain to find a matching ID. Same problem occurs again in the middle of page 377.

但是f_id上锁的问题勘误表里面没提到

pirloofmilan

重复了，删掉