重点关注：谁有能进行进程间控制的读写锁的实现啊?

richardyang

要求能同步进程，读时允许其它进程读，不允许写；写时只允许持有写锁的进行写，其它的不能读也不能写。如果不能获得锁，则程序阻塞或超时控制。

试想数据库对表的行锁的控制应该也是这种进程间的共享锁和互斥锁的综合。

不知道谁知道这方面如何实现，比较实用的那种！！！

[ 本帖最后由 richardyang 于 2008-12-30 16:32 编辑 ]

foochow

共享内存+信号量，然后和你实现一般的读写锁一样了

foochow

或者直接用ACE_Process_Mutex

foochow

或者是用ACE_RW_Process_Mutex，它是用文件锁来实现的

richardyang

我设计了一个，大概思路是这样的，大家看有没啥漏洞：
一个信号灯，四个成员
初始:    w1=1     写信号量
         w2=0     防读的写信号量(用两个来防止死锁)
         r=0      读信号量，0时才能获得写
         a=1      总控信号量的获取

写加锁WriteLock()：        
0 lock a                                                     //获取总控信号量
1 unlock w2                                               //置有写信号，防止其它的读
2 if try wait r=0                                          //快速查看是否有读，用IPC_NOWAIT
    go ... 3                                                 //无读，去检测3步的写信号量   
  else                                                      
      unlock a                                                //释放总控信号量，转为阻塞在r上
    wait r=0                                                 //改为!IPC_NOWAIT,等待无读信号

3 if try lock w1                                             //快速查看无写
     success                                                   成功，
     unlock a                                              //释放总控信号量，依赖路径是否是2的try，否则已经释放过了
  else                                                         否则
     lock w1 等待                                            //转为长等待，等w1，即无写  
     
            
write   ... ...


写解锁WriteUnlock()：         
1 unlock w1                                                  //释放防写信号
2 lock w2                                                    //释放防读信号
      

读加锁ReadLock()：
0 lock a                                                     //获取总控信号量
1  if try wait w2=0                                          //快速查看是否有写，用IPC_NOWAIT
        go ... 2                                             //无写，去2释放总控信号量
     else                                                    //有写
        unlock a                                             //释放总控信号量，转为等待w2信号赖宁嘎
        wait w2=0                                            //改为!IPC_NOWAIT,等待w2信号
        
2 unlock r                                                   //标记为有读
3 if !unlock a                                               //如果是1成功，则这里满足条件，释放总控
        unlock a


  read ... ...
  

读解锁ReadUnlock()：
1 lock r                                                     //标记为无读

[ 本帖最后由 richardyang 于 2008-12-30 18:02 编辑 ]

richardyang

没用过ACE啊，而且用ACE_RW_Process_Mutex好像只是有个定义，还没看见有实现的地方，文件锁无法实现超时，在windows下没用过啊。但是我这种锁的实现"成本"太高了啊，数据库的锁好像都用不到这么多sem。

[ 本帖最后由 richardyang 于 2008-12-30 18:27 编辑 ]

converse

你要把这个锁放在共享内存或者mmap中,可以参考我的开源项目ccache:http://code.google.com/p/commoncache/downloads/list

richardyang

主要的问题是通知机制，如果只是当成一个计数，放在共享内存肯定就可以了。主要是当查看共享内存，比如查看当前不满足条件时如何等到条件满足并解除阻塞。
另外老兄的这个pthread_rwlock_wait也是不支持超时啊，况且Pthread库在不同平台下实现也不一样，并不是都能同步进程啊。
不知道还有更好的没？

converse

>>况且Pthread库在不同平台下实现也不一样，并不是都能同步进程啊
这个我还是第一次听说,我关注一下这个问题.

todaygood

实现原理应该类似于linux内核中的自旋锁（读写自旋锁），没有获得锁则忙等直到获得，但自旋锁没有超时控制。

pthread.h中有类似的函数，不过我没用过(做应用程序比较少),下面的 pthread_rwlock_timedwrlock 这个函数有超时处理。

extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
                                __const pthread_rwlockattr_t *__restrict
                                __attr) __THROW __nonnull ((1));

/* Destroy read-write lock RWLOCK.  */
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     __THROW __nonnull ((1));

/* Acquire read lock for RWLOCK.  */
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     __THROW __nonnull ((1));

/* Try to acquire read lock for RWLOCK.  */
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  __THROW __nonnull ((1));

# ifdef __USE_XOPEN2K
/* Try to acquire read lock for RWLOCK or return after specfied time.  */
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict
                                       __abstime) __THROW __nonnull ((1, 2));
# endif

/* Acquire write lock for RWLOCK.  */
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     __THROW __nonnull ((1));

/* Try to acquire write lock for RWLOCK.  */
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     __THROW __nonnull ((1));

# ifdef __USE_XOPEN2K
/* Try to acquire write lock for RWLOCK or return after specfied time.  */
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
                                       __const struct timespec *__restrict
                                       __abstime) __THROW __nonnull ((1, 2));
# endif
                                    __abstime) __THROW __nonnull ((1, 2));
#endif