导致意外堆栈溢出错误的关闭检查

Question

我正在尝试使用此代码来更好地理解this 、 owner和delegate在 Groovy 闭包中的工作方式：

class GroovyTest {
    static void main(String[] args) {
        examine() {
            println 'In first closure'
            println "class is ${getClass().name}"
            println "this is $this, super: ${this.getClass().getSuperclass().name}"
            println "owner is $owner, super: ${owner.getClass().getSuperclass().name}"
            println "delegate is $delegate, super: ${delegate.getClass().getSuperclass().name}"

            examine() {
                println 'In closure within the closure'
                println "class is ${getClass().name}"
                println "this is $this, super: ${this.getClass().getSuperclass().name}"
                println "owner is $owner, super: ${owner.getClass().getSuperclass().name}"
                println "delegate is $delegate, super: ${delegate.getClass().getSuperclass().name}"
            }
        }
    }

    static examine(closure) {
        closure()
    }
}

当我执行此代码时，它会导致堆栈溢出错误，但是我很难弄清楚是什么导致了无限递归。 我在这里包括了堆栈跟踪的一部分：

Caught: java.lang.StackOverflowError
java.lang.StackOverflowError
    at GroovyTest$_main_closure1.doCall(GroovyTest.groovy:10)
    at jdk.internal.reflect.GeneratedMethodAccessor9.invoke(Unknown Source)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at GroovyTest$_main_closure1$_closure2.doCall(GroovyTest.groovy:14)
    at GroovyTest$_main_closure1$_closure2.doCall(GroovyTest.groovy)
    at jdk.internal.reflect.GeneratedMethodAccessor8.invoke(Unknown Source)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at GroovyTest.examine(GroovyTest.groovy:21)
    at jdk.internal.reflect.GeneratedMethodAccessor7.invoke(Unknown Source)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at GroovyTest$_main_closure1.doCall(GroovyTest.groovy:10)
    at jdk.internal.reflect.GeneratedMethodAccessor9.invoke(Unknown Source)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at GroovyTest$_main_closure1$_closure2.doCall(GroovyTest.groovy:14)
    at GroovyTest$_main_closure1$_closure2.doCall(GroovyTest.groovy)
    at jdk.internal.reflect.GeneratedMethodAccessor8.invoke(Unknown Source)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at GroovyTest.examine(GroovyTest.groovy:21)

看来println "owner is $owner, super: ${owner.getClass().getSuperclass().name}"行导致了无限递归。

为什么此代码会导致堆栈溢出错误，我该怎么做才能修复它？

编辑：以下脚本也包含嵌套闭包，完全按预期工作。 堆栈溢出异常不是由嵌套闭包本身引起的。 它似乎与 print 语句有关。

def examiningClosure(closure) {
  closure()
}

examiningClosure() { 
  println "In First Closure:"
  println "class is " + getClass().name
  println "this is " + this + ", super:" + this.getClass().superclass.name
  println "owner is " + owner + ", super:" + owner.getClass().superclass.name
  println "delegate is " + delegate +
              ", super:" + delegate.getClass().superclass.name
  
  examiningClosure() { 
    println "In Closure within the First Closure:"
    println "class is " + getClass().name
    println "this is " + this + ", super:" + this.getClass().superclass.name
    println "owner is " + owner + ", super:" + owner.getClass().superclass.name
    println "delegate is " + delegate +
                ", super:" + delegate.getClass().superclass.name
  }  
}

Answer 1

好的，我首先为没有花时间正确调查此事而道歉。

将尝试用实际的解释来弥补它。

原来是下面的代码：

def c = {
  println "foo"
}

println "${c}"

有点不直观地导致闭包被执行，而不是仅仅在标准输出上打印一个字符串表示：

─➤ groovy test.groovy
foo

所以在你的例子中：

class GroovyTest {
    static void main(args) {
        examine { // closure 1
            examine { // closure 2
                println "${owner}"
            }
        }
    }

    static examine(closure) {
        closure()
    }
}

（ examine方法调用后的括号可以省略）

最内层闭包的owner就是最内层闭包本身。 调用封闭闭包将导致自调用的无限递归，并最终导致StackOverflowException 。

例如，您可以通过println "${owner.getClass()}"来解决此问题，以防止隐式闭包调用。

我不得不说，来自"${closure}"的关闭调用非常不直观，而且完全不是我所期望的......经过多年使用 groovy......但它确实存在。