Scala/Java中的等效锁? [英] Equivalence lock in Scala/Java?

问题描述

无论如何，例如在Scala/Java中，是否可以锁定对象相等性而不是引用相等性

Is there anyway to lock on the object equality instead of referential equality in Scala/Java e.g.

def run[A](id: A) = id.synchronized {
  println(s"Processing $id")
  Thread.sleep(5000)
  println(s"Done processing $id")
}

Seq(1, 1, 2, 3, 1).par.foreach(run)

我希望它打印类似:

Processing 3
Processing 1
Processing 2
// 5 seconds later
Done processing 1
Done processing 2
Done processing 3
Processing 1
// 5 seconds later
Done processing 1
Processing 1
// 5 seconds later
Done processing 1

推荐答案

我能想到的最好的方法是这样的:

The best I could come up with is something like this:

import scala.collection.mutable

class EquivalenceLock[A] {
  private[this] val keys = mutable.Map.empty[A, AnyRef]

  def apply[B](key: A)(f: => B): B = {
    val lock = keys.synchronized(keys.getOrElseUpdate(key, new Object()))
    lock.synchronized(f)
  }
}

然后将其用作:

def run[A](id: A)(implicit lock: EquivalenceLock[A]) = lock(id) {
  println(s"Processing $id")
  Thread.sleep(5000)
  println(s"Done processing $id")
}

使用注释中提到的锁条，这是一个简单的实现:

Using the lock striping mentioned in the comments, here is a naive implementation:

/**
  * An util that provides synchronization using value equality rather than referential equality
  * It is guaranteed that if two objects are value-equal, their corresponding blocks are invoked mutually exclusively.
  * But the converse may not be true i.e. if two objects are not value-equal, they may be invoked exclusively too
  *
  * @param n There is a 1/(2^n) probability that two invocations that could be invoked concurrently is not invoked concurrently
  *
  * Example usage:
  *   private[this] val lock = new EquivalenceLock()
  *   def run(person: Person) = lock(person) { .... }
  */
class EquivalenceLock(n: Int) {
  val size = 1<<n
  private[this] val locks = IndexedSeq.fill(size)(new Object())

  def apply[A](lock: Any) = locks(lock.hashCode().abs & (size - 1)).synchronized[A] _   // synchronize on the (lock.hashCode % locks.length)th object
}

object EquivalenceLock {
  val defaultInstance = new EquivalenceLock(10)
}

番石榴的条纹最适合您不想在这里重新发明轮子的情况

Guava's Striped is best suited if you don't want to reinvent the wheel here.

这篇关于Scala/Java中的等效锁?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！