Eu tenho três perguntas.

Para explicar, eu estava revendo o código de alguém e percebiBufferedReaders às vezes não estão sendo fechados. Normalmente, o Eclipse avisa que esse é um possível vazamento de memória (e eu corrijo). No entanto, dentro de uma classe interna Callable, não há aviso.

class outerClass {
    ...
    public void someMethod() {
        Future<Integer> future = outputThreadPool.submit(new innerClass(this.myProcess.getInputStream(), threadName));
        ...
    }

    class innerClass implements Callable<Integer> {
        private final InputStream stream;
        private final String prepend;

        innerClass(InputStream stream, String prepend) {
            this.stream = stream;
            this.prepend = prepend;
        }

        @Override
        public Integer call() {
            BufferedReader stdOut = new BufferedReader(new InputStreamReader(stream));
            String output = null;
            try {
                while ((output = stdOut.readLine()) != null) {
                    log.info("[" + prepend + "] " + output);
                }

            } catch (IOException ignore) {
            // I have no idea why we're ignoring this... :-|        
            }
            return 0;   
        }
    }
}

As pessoas que escreveram o código são experientes desenvolvedores de Java, então meu primeiro pensamento é que é intencional ... mas pode ser que eles estivessem com pressa quando o escreveram e apenas ignoraram.

Minhas perguntas são:

Por que o Eclipse não destaca isso (que pode ser respondido pela resposta às seguintes perguntas)?

Qual é o pior que poderia acontecer se fosse fechado dentro do método call ()? (Eu não consigo pensar em um bom motivo ... e eu tenho procurado por um tempo ... mas talvez tenha sido intencional não fechar o BufferedReader)

Qual é o pior que poderia acontecer se o BufferedReader fossenão fechado dentro da classe interna?