如何通过Java并发锁实现此类用例

Question

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

因此，对于此用例：

最重要的是，由于getKey1()和getKey2()几乎同时调用，因此我们必须确保

1. 如果flag为true，则更新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://zh.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;
    }

参考： 如何确定对象是否被锁定同步所以不阻塞Java