在对象的方法内部调用wait方法时会发生什么？

Question

我在主线程中有如下方法，该方法在我的数据结构上调用如下方法：

public static void main(String[] args){

data_structure_object.insert(value);
}

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

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();

问题是，这是确保公平并锁定线程以保持数据结构一致性的有效方法吗？ 除了所有这些，我还无法弄清楚如何提供以下功能-：“允许多个读取器获取锁并读取数据，直到没有任何写入器请求或写入资源为止”，我对此感到非常困惑情况会有所帮助。

Answer 1

除了您试图复制一个完美的现有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出状态，有时会断裂。

您可能最好将其移至代码审查。