0

我在主线程中有如下方法，它在我的数据结构上调用一个方法，如下所示：

public static void main(String[] args){

data_structure_object.insert(value);
}

我在用于防止线程干扰的数据结构类中使用了一个称为 rwLock 的 ReadWrite 对象，ReadWrite 类如下所示：

public class ReadWriteLocks {

    // these 3 variables help in creating a read write lock
    private int numberOfReaders = 0;
    private int numberOfWriters = 0;
    private int numberOfWriteRequests = 0;

    // getter method for the number of readers
    public int getNumberOfReaders() {
        return this.numberOfReaders;
    }

    // getter method for the number of writers
    public int getNumberOfWriters() {
        return this.numberOfWriters;
    }

    // getter method for the number of write requests
    public int getNumberOfWriteRequests() {
        return this.numberOfWriteRequests;
    }

    // this function checks if a thread can acquire the lock
    public synchronized void lockRead() throws InterruptedException {

        while (numberOfWriters > 0 || numberOfWriteRequests > 0)
            this.wait();
    }

    // this function unlocks a lock occupied by a reader thread
    public synchronized void unlockRead() {

        // decrement the number of readers
        --numberOfReaders;
        notifyAll();
    }

    // this function checks if a thread can acquire the write lock
    public synchronized void lockWrite() throws InterruptedException {

        // increase the number of write requests
        ++numberOfWriteRequests;

        while (numberOfReaders > 0 || numberOfWriters > 0)
            this.wait();

        --numberOfWriteRequests;
        ++numberOfWriters;
    }

    // this function is used to take a thread away from the lock
    public synchronized void unlockWrite() {

        // decrement the number of writers
        --numberOfWriters;

        // notify all the threads
        this.notifyAll();
    }

}

在数据结构的插入方法中，我包含以下代码片段

// acquire the read/write lock
        try {
            rwLock.lockRead();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Some operation

        // release the lock
        rwLock.unlockRead();

问题是，这是确保公平性并锁定线程以保持数据结构一致性的有效方法吗？除此之外，我不知道如何提供以下功能-：“允许多个读者获取锁并读取数据，直到没有作者请求或写入资源”，我很困惑这种情况请帮忙。

4

1 回答 1

0

除了您试图复制一个完美的现有ReadWriteLock冒充的事实之外，ReentrantReadWriteLock您的代码中还有两个特定的问题：

  1. 您的实例变量应该是volatile.

    private volatile int numberOfReaders = 0;
private volatile int numberOfWriters = 0;
private volatile int numberOfWriteRequests = 0;

  2. 您需要小心从锁请求到锁定的转换。

    --numberOfWriteRequests;
++numberOfWriters;

可能应该是

    ++numberOfWriters;
    --numberOfWriteRequests;

因为在这两个指令之间可能有一个时刻numberOfWriteRequests是零和numberOfWriters零。这会让你的自旋循环lockRead出来，事情会中断......有时。

您可能最好将其转移到代码审查中。

于 2013-09-20T22:54:31.920 回答