同步块是否有最大可重入限制?

Ordinary Java code with nested synchronized blocks can never get anywhere near 60,000 acquisitions in one method, as the bytecode is limited to 65536 bytes and it takes up to 30 bytes for a javac compiled synchronized block. But the same monitor can get acquired in nested method invocations.

对于探索普通 Java 代码的限制，扩展您的问题的代码并不难.你只需要放弃缩进它:

For exploring the limits with ordinary Java code, expanding the code of your question is not so hard. You just have to give up indenting it:

public class MaxSynchronized {
    static final Object LOCK = new Object(); // potentially visible to other threads
    static int COUNT = 0;
    public static void main(String[] args) {
        try {
            testNested(LOCK);
        } catch(Throwable t) {
            System.out.println(t+" at depth "+COUNT);
        }
    }

    private static void testNested(Object o) {
        // copy as often as you like
        synchronized(o) { synchronized(o) { synchronized(o) { synchronized(o) {
        synchronized(o) { synchronized(o) { synchronized(o) { synchronized(o) {
        synchronized(o) { synchronized(o) { synchronized(o) { synchronized(o) {
        synchronized(o) { synchronized(o) { synchronized(o) { synchronized(o) {
            COUNT ++;
            testNested(o);
        // copy as often as you copied the synchronized... line
        } } } }
        } } } }
        } } } }
        } } } }
    }
}

该方法将调用自身以使嵌套获取的数量与嵌套调用的数量乘以方法内嵌套的同步块的数量相匹配.

The method will invoke itself to have a number of nested acquisitions matching the number of nested invocation times the number of nested synchronized blocks within method.

当你像上面那样用少量的 synchronized 块运行它时，你会在大量调用之后得到一个 StackOverflowError，它会随着运行而变化并且受到 -Xcomp 或 -Xint 等选项的影响，表明它受上述不确定堆栈大小的影响.

When you run it with the small number of synchronized blocks as above, you’ll get a StackOverflowError after a large number of invocations, which changes from run to run and is affected by the presence of options like -Xcomp or -Xint, indicating that it subject to the indeterministic stack size mentioned above.

但是当你显着增加嵌套 同步 块的数量时，嵌套调用的数量会变得更小且稳定.在我的环境中，当有 1,000 个嵌套 synchronized 块时，它在 30 次嵌套调用后产生 StackOverflowError，当有 2,000 个嵌套 synchronized 块时，它产生 15 次嵌套调用，非常一致，说明方法调用开销已经无关紧要了.

But when you raise the number of nested synchronized blocks significantly, the number of nested invocations becomes smaller and stable. On my environment, it produced a StackOverflowError after 30 nested calls when having 1,000 nested synchronized blocks and 15 nested calls when having 2,000 nested synchronized blocks, which is pretty consistent, indicating that the method invocation overhead has become irrelevant.

这意味着超过 30,000 次获取，大约是使用 ASM 生成的代码实现的数量的一半，考虑到 javac 生成的代码将确保获取和发布的数量相匹配，这是合理的，引入了合成局部变量持有必须为每个 synchronized 块释放的对象的引用.这个额外的变量减少了可用的堆栈大小.这也是我们现在看到 StackOverflowError 而没有 IllegalMonitorStateException 的原因，因为这段代码正确地执行了 结构化锁定.

This implies more than 30,000 acquisitions, roughly half the number achieved with the ASM generated code, which is reasonable considering that the javac generated code will ensure a matching number of acquisitions and releases, introducing a synthetic local variable holding the reference of the object that must be released for each synchronized block. This additional variable reduces the available stack size. It’s also the reason why we now see the StackOverflowError and no IllegalMonitorStateException, as this code correctly does structured locking.

与另一个示例一样，以更大的堆栈大小运行会提高报告的数字，并线性扩展.推断结果意味着它需要几个 GB 的堆栈大小才能获取监视器 Integer.MAX_VALUE 次.在这些情况下，是否有限制计数器变得无关紧要.

Like with the other example, running with larger stack size raises the reported number, scaling linearly. Extrapolating the results implies that it would need a stack size of several GB to acquire the monitor Integer.MAX_VALUE times. Whether there is a limiting counter or not, becomes irrelevant under these circumstances.

当然，这些代码示例与现实生活中的应用程序代码相去甚远，因此这里没有进行太多优化也就不足为奇了.对于现实生活中的应用程序代码，锁消除和锁粗化的可能性要高得多.此外，现实生活中的代码将自己执行需要堆栈空间的实际操作，从而使同步的堆栈需求可以忽略不计，因此没有实际限制.

Of course, these code examples are so far away from real life application code, that it should not be surprising that not much optimizations happened here. For real life application code, lock elimination and lock coarsening may happen with a much higher likelihood. Further, real life code will do actual operations needing stack space on their own, rendering the stack requirements of synchronization negligible, so there’s no practical limit.

这篇关于同步块是否有最大可重入限制?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！