如何通过 Java 并发锁实现这样的用例

Question

在下面的测试用例中，update() 方法在类外部调用，该类每小时仅由一个线程运行。但是有多个线程同时调用getKey1()和getKey2()。

所以对于这个用例：

最重要的是getKey1()和getKey2()几乎是同时调用的，一定要确定

1. 如果 flag 为真，更新 key1 和 key2 并返回新密钥
2. 如果没有，获取旧的key1和key2

我们不希望这种情况存在：更新key1并获取旧key2，但是即使我们已经更新了旧key1和key2，也可以获取少量请求。

public class Test {

    private Lock lock = new ReentrantLock();

    private AtomicBoolean flag1 = new AtomicBoolean(false);
    private AtomicBoolean flag2 = new AtomicBoolean(false);

    private volatile String key1;
    private volatile String key2;

    public Test(String key1, String key2) {
        this.key1 = key1;
        this.key2 = key2;
    }

    public void update() {
        lock.lock();
        try {
            flag1.compareAndSet(false, true);
            flag2.compareAndSet(false, true);
        } finally {
            lock.unlock();
        }
    }

    public String getKey1() {
        // TODO if the lock is holding... block over here
        if (flag1.get()) {
            // doing something for key 1
            key1 = getFromFile();
            flag1.set(false);
        }
        return key1;
    }

    public String getKey2() {
        // TODO if the lock is holding... block over here
        if (flag2.get()) {
            // doing something for key 1
            key2 = getFromFile();
            flag2.set(false);
        }
        return key1;
    }
}

我的想法是：

1. update() 运行时，阻止getKey1() 和getKey2()，等待获取更新密钥
2. update() 未运行时，getKey1() 和getKey2() 应该都可以，直接返回。
3. 当调用 getKey1() 或 getKey2() 时，我认为我们不需要阻塞 update() 方法。

有人对实现有任何想法吗？

Answer 1

如前所述，java.util.concurrent.locks.ReentrantReadWriteLock 最适合你。

把它放在你的例子中：

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    private AtomicBoolean flag1 = new AtomicBoolean(false);
    private AtomicBoolean flag2 = new AtomicBoolean(false);

    private volatile String key1;
    private volatile String key2;

    public Test(String key1, String key2) {
        this.key1 = key1;
        this.key2 = key2;
    }

    public void update() {
        Lock writeLock = lock.writeLock();
        try {
            flag1.compareAndSet(false, true);
            flag2.compareAndSet(false, true);
        } finally {
            writeLock.unlock();
        }
    }

    public String getKey1() {
        Lock readLock = lock.readLock();
        try {
            if (flag1.get()) {
                // doing something for key 1
                key1 = getFromFile();
                flag1.set(false);
            }
            return key1;
        } finally {
            readLock.unlock();
        }
    }

    public String getKey2() {
        Lock readLock = lock.readLock();
        try {
            if (flag2.get()) {
                // doing something for key 1
                key2 = getFromFile();
                flag2.set(false);
            }
            return key1;
        } finally {
            readLock.unlock();
        }
    }
}

来自ReadWriteLock 接口的文档：

读锁可能被多个读线程同时持有， 只要没有作家。写锁是独占的。

Answer 2

以下 ReadWriteLock 示例的更新，我们必须在开始读/写操作之前获取锁。由于我无权编辑示例，因此发布新答案。

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    private AtomicBoolean flag1 = new AtomicBoolean(false);
    private AtomicBoolean flag2 = new AtomicBoolean(false);

    private volatile String key1;
    private volatile String key2;

    public Test(String key1, String key2) {
        this.key1 = key1;
        this.key2 = key2;
    }

    public void update() {
        Lock writeLock = lock.writeLock();
        try {
            writeLock.lock(); 
            flag1.compareAndSet(false, true);
            flag2.compareAndSet(false, true);
        } finally {
            writeLock.unlock();
        }
    }

    public String getKey1() {
        Lock readLock = lock.readLock();
        try {
            readLock.lock(); 
            if (flag1.get()) {
                // doing something for key 1
                key1 = getFromFile();
                flag1.set(false);
            }
            return key1;
        } finally {
            readLock.unlock();
        }
    }

    public String getKey2() {
        Lock readLock = lock.readLock();
        try {
            readLock.lock();
            if (flag2.get()) {
                // doing something for key 1
                key2 = getFromFile();
                flag2.set(false);
            }
            return key1;
        } finally {
            readLock.unlock();
        }
    }
}

Answer 3

这当然是ReadWriteLock 应该提供帮助的情况。 许多并发读取器可以在很小的争用下运行，并且写入器很少获得写入锁和更新。

但是提出的关键问题是线程不能一次读取一个旧密钥和一个新密钥。

这是一个经典问题。最简单的解决方案是在更新线程中更新这两个键。

ReentrantReadWriteLock rwlock=new ReentrantReadWriteLock(true);
//If in doubt require a fair lock to avoid live-locking writes...

//...

public void update() {
    String new1=getFromFile();
    String new2=getFromFile();
    //That's the heavy lifting. Only now acquire the lock...
    Lock wlock=rwlock.writeLock();
    wlock.lock();
    try {
        key1=new1;
        key2=new2;
    } finally {
        wlock.unlock();
    }
}

在读者中：

public String[] getKeys() {
    String k1;
    String k2;
    Lock rlock=rwlock.readLock();
    rlock.lock();
    try {
        k1=key1;
        k2=key2;
    } finally {
        rlock.unlock();
    }    
    String[] r={k1,k2};
    return r;
 }

一个读写锁有两个相连的锁。多个读者可以获取读锁，但写锁不包括读者和其他写者。这是一个常见的场景，并且已经建立了解决方案。

在获取锁之前从文件中获取可能很重要，因为 I/O 通常相对较慢，您应该尽可能短地持有锁。

从同一获取锁中返回两个密钥也很重要。没有其他简单的方法可以阻止在调用getKey1() 和getKey2() 之间发生更新。

由于锁的内存屏障保证，您不再需要使用 volatile 关键字（请参阅文档）。

您实际上并不需要重入锁，但这是为读写锁提供的开箱即用的锁。

在这种情况下，称为顺序锁 (Seqlock) 的东西可能会有所帮助，但这将涉及更多编码，并且可能在此处过度设计。

参考资料：

https://en.wikipedia.org/wiki/Seqlock

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReadWriteLock.html

Answer 4

使用 tryLock()

public String getKey1() {
  if (lock.tryLock())
  {
    // Got the lock
    try
    {
        // Process record
    }
    finally
    {
        // Make sure to unlock so that we don't cause a deadlock
        lock.unlock();
    }
 }
}

如果您不希望 getKey1() 或 getKey2() 执行锁定。您可以使用以下方法，

static boolean isLocked=false;
public void update() {
        lock.lock();
        isLocked = true;
        try {
            flag1.compareAndSet(false, true);
            flag2.compareAndSet(false, true);
        } finally {
            lock.unlock();
            isLocked = false; 
        }
    }

    public String getKey1() {
        while(isLocked); #wait till the lock release.
        if (flag1.get()) {
            // doing something for key 1
            key1 = getFromFile();
            flag1.set(false);
        }
        return key1;
    }

参考：how-do-determine-if-an-object-is-locked-synchronized-so-not-to-block-in-java