自定义 scala 递归预防机制的改进

Question

我想创建一个智能的递归预防机制。我希望能够以某种方式注释一段代码，以标记它不应该在递归中执行，如果它确实在递归中执行，那么我想抛出一个自定义错误（可以捕获该错误以允许执行）发生这种情况时的自定义代码）

这是我在此之前的尝试：

import scala.collection.mutable.{Set => MutableSet, HashSet => MutableHashSet }

case class RecursionException(uniqueID:Any) extends Exception("Double recursion on " + uniqueID)

object Locking {
  var locks:MutableSet[Any] = new MutableHashSet[Any]

  def acquireLock (uniqueID:Any) : Unit = {
    if (! (locks add uniqueID))
      throw new RecursionException(uniqueID)
  }

  def releaseLock (uniqueID:Any) : Unit = {
    locks remove uniqueID
  }

  def lock1 (uniqueID:Any, f:() => Unit) : Unit = {
    acquireLock (uniqueID)
    try {
      f()
    } finally {
      releaseLock (uniqueID)
    }
  }

  def lock2[T] (uniqueID:Any, f:() => T) : T = {
    acquireLock (uniqueID)
    try {
      return f()
    } finally {
      releaseLock (uniqueID)
    }
  }
}

现在锁定我所做的代码段：

import Locking._

lock1 ("someID", () => {

  // Custom code here

})

我的问题是：

1. 是否有任何明显的方法可以消除对唯一标识符进行硬编码的需要？ strong> 我需要一个实际共享的唯一标识符在包含锁定部分的函数的所有调用之间（所以我不能有类似计数器的东西来生成唯一值，除非不知何故 scala 有静态函数变量）。我以某种方式思考
2. 有没有办法美化匿名函数的语法？具体来说，有一些东西会让我的代码看起来像lock1(“id”){/*代码放在这里* / } 或任何其他更漂亮的外观。
3. 在这个阶段问有点傻，但我还是会问 - 我是在重新发明轮子吗？（即是否存在这样的事情？）

疯狂的最终想法： > 我知道滥用 synchronized 关键字（至少在 java 中）可以保证代码只会执行一次（从某种意义上说，没有多个线程可以在同一时刻进入该部分代码）同一时间）。我不认为它会阻止同一个线程执行代码两次（尽管我在这里可能是错的）。不管怎样，如果它确实阻止了它，我仍然不想要它（即使我的程序是单线程的），因为我很确定它会导致死锁并且不会报告异常。

编辑：为了更清楚地说明，该项目用于错误调试目的和学习 scala。除了在运行时轻松查找代码错误（用于检测不应该发生的递归）之外，它没有真正的用途。请参阅这篇文章的评论。

Answer 1

不太确定您的目标是什么，但有几点说明：

首先，您不需要执行 lock1 和 lock2 来区分 Unit 和其他类型。 Unit 是一个合适的值类型，通用方法也适用于它。另外，您可能应该使用按名称调用参数 => T，而不是函数 () => T，并使用两个参数列表：

def lock[T] (uniqueID:Any)(f: => T) : T = {
  acquireLock (uniqueID)
  try {
    f
  } finally {
    releaseLock (uniqueID)
  }
}

然后您可以使用lock(id){block}进行调用，它看起来像常见的指令，例如if或synchronized。

第二，为什么需要uniqueId，为什么要把Lock做成单例？相反，让 Lock 成为一个类，并拥有与 id 一样多的实例。

class Lock {
  def lock[T](f: => T): T = {acquireLock() ...}
}

（您甚至可以将锁定方法命名为 apply，这样您就可以执行 myLock{....} 而不是 myLock.lock{...}< /code>)

抛开多线程不谈，你现在只需要一个布尔变量来acquire/releaseLock

最后，如果你需要支持多线程，你必须决定是否有多个线程可以进入锁（这不会是递归）。如果可以的话，布尔值应该替换为 DynamicVariable[Boolean] （或者可能是 java ThreadLocal，因为 DynamicVariable 是一个 InheritableThreadLocal，您可能想要也可能不想要）。如果不能，您只需在acquire/releaseLock中同步访问即可。

Answer 2

是否有任何明显的方法可以消除对唯一标识符进行硬编码的需要？

由于您在评论中所说的这不是产品代码，我想您可以使用函数 hashCode 属性如下：

def lock1 (f:() => Unit) : Unit = {
    acquireLock (f.hashCode)
    try {
      f()
    } finally {
      releaseLock (f.hashCode)
    }

有什么方法可以美化匿名函数的语法吗？

通过前面提到的更改，语法应该更漂亮：

lock1 {

如果您打算保留标识符（如果 hashcode 不适合你）你可以像这样定义你的方法：

def lock1 (uniqueID:Any)(f:() => Unit) : Unit = {

这将让你调用 lock1 方法：

lock("foo") {

}

干杯！