在Scala/Java中使用AtomicBoolean进行数据库锁定安全吗？

Question

我有一个应用程序，我想确保一个方法最多同时调用一次，比如在更新数据库中的用户余额时。

我想到的是使用下面的锁体：（显示Scala代码的下方，而应该是与Java Lambda表达式类似）：

object Foo{ 
    val dbLocked = new java.util.concurrent.atomic.AtomicBoolean(false) 

    def usingAtoimcDB[T](f: => T):T = { 
     if (dbLocked.get) throw new Exception("db is locked") 
     dbLocked.set(true) 
     try f 
     finally dbLocked.set(false)  
    } 
} 

这是安全使用时usingAtoimcDB可以同时叫什么名字？

编辑：下面的校正码，如指向this answer：

def usingAtoimcDB[T](f: => T):T = { 
    if(dbLocked.compareAndSet(false, true)) { 
    //db is now locked 
    try f 
    finally dbLocked.set(false) 
    } else { 
    //db is already locked 
    throw new Exception("db is locked") 
    } 
} 

编辑2：

使用SPINLOOP。这也可以吗？

def usingAtoimcDB[T](f: => T):T = { 
    while (!dbLocked.compareAndSet(false, true)) {Thread.sleep(1)} 
    try f 
    finally dbLocked.set(false) 
} 

编辑3：根据下面的答案和评论，我也在考虑使用队列。

Answer 1

是的，它应该按照预期工作。我会使用compareAndSet调用稍微修改您的功能。

compareAndSet方法具有的优点是一个原子操作 - 不存在竞争条件和值将被原子地改变。

def usingAtoimcDB[T](f: => T):T = { 
    if(dbLocked.compareAndSet(false, true)) { 
    //db is now locked 
    try f 
    finally dbLocked.set(false) 
    } else { 
    //db is already locked 
    throw new Exception("db is locked") 
    } 
} 

Answer 2

您上面发布的代码不是线程安全的，因为您没有使用原子检查和设置操作。两个线程都可以同时执行if (dbLocked.get)语句，并且两者都获得false作为答案，然后两者都将执行dbLocked.set(true)并呼叫f。

如果你真的想用AtomicBoolean，则必须使用compareAndSet作为@leshkin已经表明 - 这是一个原子操作，做了检查，一气呵成，不另一个线程的同时做同样的事情的可能性集时间，以便它是线程安全的。

您使用的是AtomicBoolean这里的锁。标准Java库中有一些类更适合（并且特别制作）用于此目的;看看包裹java.util.concurrent.locks。

例如，你可以使用类ReentrantReadWriteLock，它结合了用于读取和写入两把锁。写锁定是独占的（当它被锁定时，没有其他人可以读或写）;读锁定是共享的（锁定时，没有人可以写入，但其他人可以同时读取）。这允许同时存在多个读取器，但是一次只有一个写入器，可能提高效率（不需要使读取专用操作）。

实施例：

import java.util.concurrent.locks._ 

object Foo { 
    private val lock: ReadWriteLock = new ReentrantReadWriteLock 

    def doWriteOperation[T](f: => T): T = { 
    // Locks the write lock 
    lock.writeLock.lock() 
    try { 
     f 
    } finally { 
     lock.writeLock.unlock() 
    } 
    } 

    def doReadOperation[T](f: => T): T = { 
    // Locks the read lock 
    lock.readLock.lock() 
    try { 
     f 
    } finally { 
     lock.readLock.unlock() 
    } 
    } 
} 

Answer 3

不可取的。您正在请求在同一台服务器上的同一个应用程序实例中运行的同一代码是执行该事务的单个点。也没有规定让这个代码脱颖而出。当你退休时，有人可能会开始第二个应用程序实例或其他任何事情。

数据库提交/回滚是一个非常简单和可靠的机制。

当您无法编写集成（单元）测试以确保唯一的一点时，请不要这样做。

如果你做到这一点：

• 撤销权的表修改为普通的数据库用户
• 添加一个新的数据库使用谁有足够的权利授予

而且还是：不做到这一点。