try-resource-block中的AutoCloseable延迟执行

Question

I have noticed that the execution of the close method on AutoCloseable objects is sometimes delayed. It's normally executed within a millisec or two, but sometimes it takes up to a hundred millisecs or more.

I am unable to find Java documentation describing the expected timing of try-with-resource. Can someone help explain what why there is sometimes such a large delay?

Below is a test to show this. The results vary, but if ran enough, results begin to show delayed execution of the close method.

public class ClosableTest {
    public class TimerResource implements AutoCloseable {
        private Instant startTime;
        private long sleepTime;
        private long actualTime;

        public TimerResource() {
            startTime = Instant.now();
        }

        public void setSleepTime(long sleepTime) {
            this.sleepTime = sleepTime;
        }

        public void setActualTime(long actualTime) {
            this.actualTime = actualTime;
        }

        @Override
        public void close() throws Exception {
            long closeTime = Duration.between(startTime, Instant.now()).toMillis();
            //System.out.println(String.format("%s: Sleep time: %d; Actual time: %d; Closed time: %s", Thread.currentThread().getName(), sleepTime, actualTime, closeTime));
            if (closeTime > actualTime+5) {
                System.out.println("Close took more than 5ms");
                System.out.println(String.format("\t%s: Sleep time: %d; Actual time: %d; Closed time: %s", Thread.currentThread().getName(), sleepTime, actualTime, closeTime));
            }
        }
    }

    @Test
    public void timingTest() {
        Instant start;
        long realDuration;

        for (int i = 0; i < 100; i++) {
            try (TimerResource timer = new TimerResource()) {
                start = Instant.now();

                long sleepTime = 10L + (long) (400 * Math.random());
                timer.setSleepTime(sleepTime);
                Thread.sleep(sleepTime);

                realDuration = Duration.between(start, Instant.now()).toMillis();
                timer.setActualTime(realDuration);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 1

The close() is called immediately. However when you try to determine this empirically, you are only as reliable as your benchmark.

BTW If you call System.nanoTime() in a tight loop, you can see jumps in time of 1 - 50 ms due to the process being rescheduled. You can see this on your machine by running this test tools https://github.com/OpenHFT/Java-Thread-Affinity/blob/master/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java

If you look at the byte code for this example.

public static void main(String... args) {
    try (PrintWriter pw = new PrintWriter(System.out)) {
        pw.println("Hello World");
    }
}

you can see that close is called immediately after println

   L11
    LINENUMBER 13 L11
    NEW java/io/PrintWriter
    DUP
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    INVOKESPECIAL java/io/PrintWriter.<init> (Ljava/io/OutputStream;)V
    ASTORE 1
   L12
    ACONST_NULL
    ASTORE 2
   L3
    LINENUMBER 14 L3
    ALOAD 1
    LDC "Hello World"
    INVOKEVIRTUAL java/io/PrintWriter.println (Ljava/lang/String;)V
   L4
    LINENUMBER 15 L4
    ALOAD 1
    IFNULL L13
    ALOAD 2
    IFNULL L14
   L0
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintWriter.close ()V
   L1
    GOTO L13
   L2

For the sake of brevity I have removed the try/finally byte code which is not executed unless there is a Throwable.

Answer 2

I don't believe there should be a significant difference between both cases. As per java docs . Try with resource translate like below.

Suppose your try with resource looks like

try ({VariableModifier} R Identifier = Expression ...)
    Block

Will translate to :

{
    final {VariableModifierNoFinal} R Identifier = Expression;
    Throwable #primaryExc = null;

    try ResourceSpecification_tail
        Block
    catch (Throwable #t) {
        #primaryExc = #t;
        throw #t;
    } finally {
        if (Identifier != null) {
            if (#primaryExc != null) {
                try {
                    Identifier.close();
                } catch (Throwable #suppressedExc) {
                    #primaryExc.addSuppressed(#suppressedExc);
                }
            } else {
                Identifier.close();
            }
        }
    }
}

So it is clear that try with resource and normal try-catch are nearly same . The only difference is that you may put / or not all the checks generated during translation of the try with resource .

Can someone help explain what why there is sometimes such a large delay?

Sometimes large delay may be due to several reason like CPU usage at that time, available memory, GC etc.