Scala / Java中的等效锁？

Question

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

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)

I want this to print something like:

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

Answer 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)
  }
}

Then use it as:

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

EDIT: 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.