仅使用互斥锁的读/写锁实现？

Question

我试图只使用互斥锁来实现读/写锁（仅用于学习）。正当我想我已经覆盖了所有的角落案例（因为程序使用了各种组合），我已经意识到，我忽略了这个事实（因为它在Ubuntu的工作），该互斥体应该由线程的所有者释放。下面是我的实施，

class rw_lock_t{ 

    int NoOfReaders; 
    int NoOfWriters, NoOfWritersWaiting; 
    pthread_mutex_t class_mutex; 
    pthread_cond_t class_cond; 
    pthread_mutex_t data_mutex; 

public: 

    rw_lock_t() 
    : NoOfReaders(0), 
     NoOfWriters(0), NoOfWritersWaiting(0) 
    { 
      pthread_mutex_init(&class_mutex, NULL); 
      pthread_mutex_init(&data_mutex, NULL); 
      pthread_cond_init(&class_cond, NULL); 
    } 
    void r_lock() 
    { 
      pthread_mutex_lock(&class_mutex); 
      //while(NoOfWriters!=0 || NoOfWritersWaiting!=0) //Writer Preference 
      while(NoOfWriters!=0) 
      { 
        pthread_cond_wait(&class_cond, &class_mutex); 
      } 
      if(NoOfReaders==0) 
      { 
        pthread_mutex_unlock(&class_mutex); 
        pthread_mutex_lock(&data_mutex); 
        pthread_mutex_lock(&class_mutex); 
        NoOfReaders++; 
        pthread_mutex_unlock(&class_mutex); 
      } 
      else if(NoOfReaders>0) //Already Locked 
      { 
        NoOfReaders++; 
        pthread_mutex_unlock(&class_mutex); 
      } 
    } 
    void w_lock() 
    { 
      pthread_mutex_lock(&class_mutex); 
      NoOfWritersWaiting++; 
      while(NoOfReaders!=0 && NoOfWriters!=0) 
      { 
        pthread_cond_wait(&class_cond, &class_mutex); 
      } 
      pthread_mutex_unlock(&class_mutex); 

      pthread_mutex_lock(&data_mutex); 
      pthread_mutex_lock(&class_mutex); 
      NoOfWritersWaiting--; NoOfWriters++; 
      pthread_mutex_unlock(&class_mutex); 
    } 
    void r_unlock() 
    { 
      pthread_mutex_lock(&class_mutex); 
      NoOfReaders--; 
      if(NoOfReaders==0) 
        pthread_mutex_unlock(&data_mutex); 
      pthread_mutex_unlock(&class_mutex); 
      pthread_cond_signal(&class_cond); 
    } 
    void w_unlock() 
    { 
      pthread_mutex_lock(&class_mutex); 
      NoOfWriters--; 
      if(NoOfWriters==0) 
        pthread_mutex_unlock(&data_mutex); 
      pthread_mutex_unlock(&class_mutex); 
      pthread_cond_signal(&class_cond); 
    } 
}; 

我现在的问题是，什么是最好的方式（微小的变化）纠正。信号量绝对是空闲的选择，但我认为解决方案如下

解决方案＃1

1）我将有一个专门的线程，只锁定/解锁读情况互斥。

2）此线程将等待条件变量从r_lock或r_unlock获取信号。

3）r_lock和r_unlock将代替执行“pthread_mutex_lock/unlock（& data_mutex）;”，而是指示专用线程锁定。

4）我要记住许多事实对于此实现，

• 的信令和实际锁定是两个不同的事件，因此可能需要同步。

• 将需要一个互斥+ condVariable +线程和更多的同步额外。

更新：解决方案2

1）谁做实际的锁定将保持其全球范围的TID线程。 2）每当线程解锁将确保与全局tid检查相等。 3）如果匹配将等待“NoOfReaders == 0”条件并解锁它。

那么，有没有更好的方法可以纠正程序。

Answer 1

你不需要一个单独的互斥“数据”;如果其内部逻辑是正确的，则整个构造将用作数据锁定。相反，您可以为读者和作者使用两个单独的条件变量，以便您可以在不影响等待作者的情况下广播所有等待的读者。代码如下;你也可以看到这样更简单。此外，我添加了一个析构函数并修复了w_lock中的一个错误：等待的条件应该是(NoOfReaders!=0 || NoOfWriters!=0)，而不是&&。

class rw_lock_t { 

    int NoOfReaders; 
    int NoOfWriters, NoOfWritersWaiting; 
    pthread_mutex_t class_mutex; 
    pthread_cond_t reader_gate; 
    pthread_cond_t writer_gate; 

public: 

    rw_lock_t() 
    : NoOfReaders(0), NoOfWriters(0), NoOfWritersWating(0), 
     class_mutex(PTHREAD_MUTEX_INITIALIZER), 
     reader_gate(PTHREAD_COND_INITIALIZER), 
     writer_gate(PTHREAD_COND_INITIALIZER) 
    {} 
    ~rw_lock_t() 
    { 
     pthread_mutex_destroy(&class_mutex); 
     pthread_cond_destroy(&reader_gate); 
     pthread_cond_destroy(&writer_gate); 
    } 
    void r_lock() 
    { 
     pthread_mutex_lock(&class_mutex); 
     //while(NoOfWriters>0 || NoOfWritersWaiting>0) //Writer Preference 
     while(NoOfWriters>0) 
     { 
      pthread_cond_wait(&reader_gate, &class_mutex); 
     } 
     NoOfReaders++;   
     pthread_mutex_unlock(&class_mutex); 
    } 
    void w_lock() 
    { 
     pthread_mutex_lock(&class_mutex); 
     NoOfWritersWaiting++; 
     while(NoOfReaders>0 || NoOfWriters>0) 
     { 
      pthread_cond_wait(&writer_gate, &class_mutex); 
     } 
     NoOfWritersWaiting--; NoOfWriters++; 
     pthread_mutex_unlock(&class_mutex); 
    } 
    void r_unlock() 
    { 
     pthread_mutex_lock(&class_mutex); 
     NoOfReaders--; 
     if(NoOfReaders==0 && NoOfWritersWaiting>0) 
      pthread_cond_signal(&writer_gate); 
     pthread_mutex_unlock(&class_mutex); 
    } 
    void w_unlock() 
    { 
     pthread_mutex_lock(&class_mutex); 
     NoOfWriters--; 
     if(NoOfWritersWaiting>0) 
      pthread_cond_signal(&writer_gate); 
     //else //Writer Preference - don't signal readers unless no writers 
     pthread_cond_broadcast(&reader_gate); 
     pthread_mutex_unlock(&class_mutex); 
    } 
}; 

Answer 2

class ReadWriteLock { 
    mutex writeLock; 
    mutex readLock; 
    int readCount; 
public: 
    ReadWriteLock() { 
     readCount = 0; 
    } 
    void LockWrite() { 
     writeLock.lock(); 
    } 
    void UnlockWrite() { 
     writeLock.unlock(); 
    } 
    void LockRead() { 
     lock_guard<mutex> lock(readLock); 
     ++readCount; 
     if (1 == readCount) { 
      LockWrite(); 
     } 
    } 
    void UnlockRead() { 
     lock_guard<mutex> lock(readLock); 
     --readCount; 
     if (0 == readCount) { 
      UnlockWrite(); 
     } 
    } 
}; 

正如阿列克谢指出，如果最后一次读线程UnlockWrite不是第一次读线程LockWrite，该行为是不确定的。请参阅 std :: mutex :: unlock http://www.cplusplus.com/reference/mutex/mutex/unlock/ Windows ReleaseMutex：http://msdn.microsoft.com/en-us/library/windows/desktop/ms685066(v=vs.85).aspx