⽤互斥锁实现读写锁，写者优先

读写锁是一种常见的同步机制，用于控制多个线程对共享资源的访问。读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。同时，写入操作比读取操作具有更高的优先级，以确保写入的数据不会被读取线程干扰。

以下是使用互斥锁实现读写锁，写者优先的示例代码：

public class ReadWriteLock {
    private int readers = 0;
    private int writers = 0;
    private int writeRequests = 0;
    private boolean preferWriter = true;
    private Lock lock = new ReentrantLock();
    private Condition noReaders = lock.newCondition();
    private Condition noWriters = lock.newCondition();

    public void readLock() throws InterruptedException {
        lock.lock();
        try {
            while (writers > 0 || (preferWriter && writeRequests > 0)) {
                noReaders.await();
            }
            readers++;
        } finally {
            lock.unlock();
        }
    }

    public void readUnlock() {
        lock.lock();
        try {
            readers--;
            preferWriter = true;
            noWriters.signal();
        } finally {
            lock.unlock();
        }
    }

    public void writeLock() throws InterruptedException {
        lock.lock();
        try {
            writeRequests++;
            while (readers > 0 || writers > 0) {
                noWriters.await();
            }
            writeRequests--;
            writers++;
        } finally {
            lock.unlock();
        }
    }

    public void writeUnlock() {
        lock.lock();
        try {
            writers--;
            preferWriter = false;
            noReaders.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

在上面的代码中，我们使用了一个`Lock`和两个`Condition`来实现读写锁，写者优先。`preferWriter`表示当前是否优先处理写操作，`noReaders`和`noWriters`分别表示没有读者和没有写者的条件变量。

在`readLock()`方法中，如果当前有写者或者写请求且写者优先，则等待条件变量`noReaders`。否则，读取线程数加1。

在`readUnlock()`方法中，读取线程数减1，并设置`preferWriter`为`true`，表示优先处理写操作。然后，唤醒条件变量`noWriters`。

在`writeLock()`方法中，写请求数加1。如果当前有读者或写者，则等待条件变量`noWriters`。否则，将写请求数减1，写者数加1。

在`writeUnlock()`方法中，写者数减1，并设置`preferWriter`为`false`，表示不再优先处理写操作。然后，唤醒条件变量`noReaders`。

需要注意的是，在使用读写锁时，读取操作和写入操作必须调用相应的读锁和写锁方法，以确保同步正确。