¿Por qué utilizar Atómica aquí?

raging_sweet:

Mientras lee el código fuente de SpringRetry, me encuentro con este fragmento de código:

private static class AnnotationMethodsResolver {

    private Class<? extends Annotation> annotationType;

    public AnnotationMethodsResolver(Class<? extends Annotation> annotationType) {
        this.annotationType = annotationType;
    }

    public boolean hasAnnotatedMethods(Class<?> clazz) {
        final AtomicBoolean found = new AtomicBoolean(false);
        ReflectionUtils.doWithMethods(clazz,
                new MethodCallback() {
                    @Override
                    public void doWith(Method method) throws IllegalArgumentException,
                            IllegalAccessException {
                        if (found.get()) {
                            return;
                        }
                        Annotation annotation = AnnotationUtils.findAnnotation(method,
                                annotationType);
                        if (annotation != null) { found.set(true); }
                    }
        });
        return found.get();
    }

}

Mi pregunta es, ¿por qué usar AtomicBooleancomo variable local aquí? He comprobado el código fuente de RelfectionUtils.doWithMethods()y no encontrar ninguna invocación de concurrencia allí.

tgdavies:

Cada invocación hasAnnotatedMethodsobtiene su propia instancia de found, por lo que el contexto en el que hasAnnotatedMethodsse llama no importa.

Es posible que ReflectionUtils.doWithMethodsllama al doWithmétodo de múltiples hilos, lo que requeriría doWithser segura hilo.

Sospecho que AtomicBooleansolo se utiliza para devolver un valor de la devolución de llamada, y que boolean[] found = new boolean[1];podría hacer igual de bien.