Question

我被赋予了使用POSIX线程编写读写实现的任务。我想知道我的实现是否适用于这两种情况：

可怕的尝试被删除

尝试2号

读者偏好：

变量：

int readersActive_;

sem_t lock_;
sem_t writeLock_;

实现：

void PalindromeDatabase::lockReaders()
{
    sem_wait(&lock_);
    {
        ++readersActive_;

        if (readersActive_ == 1)
            sem_wait(&writeLock_);
    }
    sem_post(&lock_);
}

void PalindromeDatabase::unlockReaders()
{
    sem_wait(&lock_);
    {
        --readersActive_;

        if (readersActive_ == 0)
            sem_post(&writeLock_);
    }
    sem_post(&lock_);
}

void PalindromeDatabase::lockWriters()
{
    sem_wait(&writeLock_);
}

void PalindromeDatabase::unlockWriters()
{
    sem_post(&writeLock_);
}

作家首选：

变量：

int readersActive_;
int readersWaiting_;

int writersActive_;
int writersWaiting_;

pthread_mutex_t lock_;
pthread_cond_t read_;
pthread_cond_t write_;

实现：

void PalindromeDatabase::lockReaders()
{
    pthread_mutex_lock(&lock_);
    {
        if (writersActive_ || writersWaiting_)
        {
            ++readersWaiting_;

            do
            {
                pthread_cond_wait(&read_, &lock_);
            } while(writersActive_ || writersWaiting_);

            --readersWaiting_;
        }

        ++readersActive_;
    }
    pthread_mutex_unlock(&lock_);
}

void PalindromeDatabase::unlockReaders()
{
    pthread_mutex_lock(&lock_);
    {
        --readersActive_;

        if (writersWaiting_)
            pthread_cond_signal(&write_);
    }
    pthread_mutex_unlock(&lock_);
}

void PalindromeDatabase::lockWriters()
{
    pthread_mutex_lock(&lock_);
    {
        if (readersActive_ || writersActive_)
        {
            ++writersWaiting_;

            do
            {
                pthread_cond_wait(&write_, &lock_);
            } while(readersActive_ || writersActive_);

            --writersWaiting_;
        }

        writersActive_ = 1;
    }
    pthread_mutex_unlock(&lock_);
}

void PalindromeDatabase::unlockWriters()
{
    pthread_mutex_lock(&lock_);
    {
        writersActive_ = 0;

        if (writersWaiting_)
            pthread_cond_signal(&write_);
        else if (readersWaiting_)
            pthread_cond_broadcast(&read_);
    }
    pthread_mutex_unlock(&lock_);
}

线程很有趣 - 它们也让我的大脑受伤。如果我错了，请不要直接回答，但要指导我正确的方向，因为这是一项家庭作业，我和其他像我一样的人肯定会从我们自己获得解决方案中获益。

Answer 1

你的代码都不对。您必须在获得读锁定后立即释放互斥锁。在持有互斥锁时，您需要安排阻止编写器。在释放读锁定时，如果正在释放最后一个读锁定，则需要安排取消阻止编写器。

在伪代码中：

read_lock：
1）获取互斥锁。
2）增加读锁定次数 3）阻止条件变量，直到没有作者为止 4）释放互斥。

read_unlock：
1）获取互斥锁。
2）减少读锁定次数 3）如果读锁定计数为零，则唤醒写入器 4）释放互斥。

write_lock：
1）获取互斥锁。
2）如果使用作家优先权，则安排没有新的读者 3）阻止条件变量，直到没有活动的读者。（您需要阻止释放互斥锁，否则读者无法完成解锁操作！）

write_unlock：
1）唤醒等待读者/作者（取决于您正在实施的优先权）
2）释放互斥。

Answer 2

通过提示，我不认为

    // If I'm the last reader, we can let the writers work.
if (--numberOfReadersActive_)
    pthread_cond_signal(&readersActive_);

正在做评论中所说的内容。这也可能是你陷入僵局的原因。

读写首选和写入器首选读写多线程

2 个答案: