読み取り、書き込み、および排他のためのロック

Question

3種類のロックを実装する必要があります。読み取り、書き込み、排他のためのロック。たとえば、tableという名前の抽象オブジェクトがあり、多くのトランザクションは異なるスレッドから機能します。

1. Aは、ロックがあなたが同時に異なるトランザクションからのデータを読み取ることができますが、トランザクションの1つは、書き込み用のテーブルを必要とする場合、それはすべてのロックが削除されて読まれるまで待つ必要があるロックですお読みください。

2. 書き込みロックは、任意のトランザクションがテーブルから読み取ることができますが、1つのトランザクションのみがアクセスしているとき、書き込み用のテーブルを所有している1つのトランザクションのみがテーブル

3. に書き込むことができ、排他ロックがロックされロックが解除されるのを待ちます。

そして、私は、これはWINAPIを使用して実装することができ、C/C++ iの材料を勉強した後、その

class Table 
{ 
void LockWrite() 
{ 
    if (LockLW.IsLock()) 
     LockLW.wait_and_lock(); 
    // 
    if (LockEx.IsLock()) 
     LockEx.wait(); 
} 
void LockExclusive() 
{ 
    { 
     // it is assumed that this is a thread-safe check 
     if (readers != 0) 
      FreeLockRead.wait(); 
    } 
    //but there is a problem, because in this place some transactions have started to read again 

    if (LockLW.IsLock()) 
     LockLW.wait_and_lock(); 

    if (LockEx.IsLock()) 
     LockEx.wait_and_lock(); 
} 

void UnLockExclusive() 
{ 
    LockEx.unLock(); 
} 

void LockRead() 
{ 
    if (LockEx.IsLock()) 
     LockEx.wait(); 
    //Set Lock Read 
    //a problem, because in this place one of transactions have got LockEx 
    readers += 1; 
} 

void UnLockRead() 
{ 
    readers -= 1; 
    if (readers == 0) 
     FreeLockRead.pulse(); 
} 

mutex LockLW; 
mutex LockEx; 

event FreeLockRead; 
atomic readers; 
}; 

Answer 1

ようにしようとしています、私は、次の解決策た方法を探しています：

を

class Table 
{ 
enum eFlag 
{ 
    eFree = 0, 
    eRead = 1, 
    eWrite = 2, 
    eExclusive = 4 
}; 
uint32_t m_nReaders; 
std::mutex m_Mutex; 
uint32_t m_nFlag; 
std::condition_variable m_condition; 

void LockForRead() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 
    if (m_nFlag & eExclusive) 
    { 
     m_condition.wait(lk, [this]() {return !(m_nFlag & eExclusive); }); 
    } 
    m_nReaders += 1; 
    m_nFlag |= eRead; 
} 
void UnLockForRead() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 

    assert(m_nReaders != 0 && (m_nFlag & eRead)); 

    m_nReaders -= 1; 
    if (m_nReaders == 0) 
    { 
     m_nFlag &= ~eRead; 
     m_condition.notify_one(); 
    } 
} 
void LockForExclusive() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 
    if (m_nFlag != eFree) 
     m_condition.wait(lk, [this]() {return m_nFlag == eFree; }); 

    m_nFlag = eExclusive; 
} 
void UnLockForExclusive() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 

    assert(m_nFlag == eExclusive); 

    m_nFlag = eFree; 
    m_condition.notify_all(); 
} 
void LockForWrite() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 

    if (m_nFlag & (eExclusive | eWrite)) 
     m_condition.wait(lk, [this]() {return !(m_nFlag & (eExclusive | eWrite)); }); 

    m_nFlag |= eWrite; 
} 
void UnLockForWrite() 
{ 
    std::unique_lock<std::mutex> lk(m_Mutex); 

    assert(m_nFlag & eWrite); 

    m_nFlag &= ~eWrite; 
    m_condition.notify_one(); 
} 
};