2011-10-19 27 views
36

¿Cuál es la forma correcta/preferida de anotar los campos que están protegidos con un ReadWriteLock para que las herramientas como FindBugs puedan aprovechar la anotación? Debe el nombre del ReadWriteLock simplemente escribirse en la anotación @GuardedBy. ¿Alguna vez hay una razón para escribir el nombre del solo bloqueo de lectura, o simplemente el bloqueo de escritura, en la anotación @GuardedBy? ¿FindBugs u otras herramientas, incluso admiten ReadWriteLock en @GuardedBy?@GuardedBy anotación con java.util.concurrent.locks.ReadWriteLock

Respuesta

28

En el momento de escribir estas líneas, @GuardedByisn't fully implemented by Findbugs, y es más que nada para documentación. (Es parcialmente implementarse.)

siempre uso @GuardedBy("readwritelock") o el objeto que utilizo para synchronize.

Por ejemplo de este último:

class Example { 
    private Object lock = new Object(); 

    @GuardedBy("lock") 
    private Stuff innards = ...; 

    public void work() { 
     synchronized(lock) { 
      workWith(innards.goop()); 
     } 
    }   
} 
+2

Gracias! Solo una nota rápida, no sé el estado del arte FindBugs (¡por lo tanto, hice esta pregunta! :), pero el enlace que menciona que la anotación podría no implementarse parece tener cuatro años. –

+0

Ese proyecto es muy activo, a juzgar por la actividad en el rastreador de errores vinculado. –

+0

¿Te refieres al proyecto FindBugs? Oh seguro, está vivo y bien. Quise decir la declaración específica de hace cuatro años que la anotación GuardedBy podría no implementarse. Estoy diciendo que el código FindBugs más reciente podría implementarlo. Lo siento si malinterpreté o malentendí algo. –

2

encontrar errores es compatible con las siguientes anotaciones:

net.jcip.annotations.GuardedBy 
net.jcip.annotations.Immutable 
net.jcip.annotations.NotThreadSafe 
net.jcip.annotations.ThreadSafe 

uso de estos anotación GuardedBy debe ser el siguiente:

@ThreadSafe 
public class Queue<E> implements java.util.Queue<E> 
{ 
    private ConcurrentLinkedQueue readWriteLock; 

    @GuardedBy(value="readWriteLock") 
    public boolean offer(E o) 
    { 
     return queue.offer(o); 
    } 

} 
+0

Estas anotaciones también son capturados en JSR305. Se pueden ver en esta implementación de referencia: http://code.google.com/p/jsr-305/source/browse/trunk/ri/src/main/java/javax/annotation/concurrent/ –

+3

El nombre del el bloqueo se puede escribir de forma más compacta de la siguiente manera: @GuardedBy ("readWriteLock") - la porción "value =" no se requiere explícitamente. –

+1

Mi pregunta no es realmente acerca del uso básico. Estoy tratando de averiguar si un java.util.concurrent.locks.ReadWriteLock, que contiene tanto un bloqueo de lectura como un bloqueo de escritura, debe ser referido en una anotación @GuardedBy como el ReadWriteLock completo, o por la lectura y escritura individual cabellos. Y si algo de esto es efectivo. –