2011-10-19 13 views
36

Qual è un modo corretto/preferito per annotare campi protetti con uno ReadWriteLock in modo che strumenti come FindBug possano sfruttare l'annotazione? Il nome dello ReadWriteLock deve essere semplicemente scritto nell'annotazione @GuardedBy. C'è mai un motivo per scrivere il nome di solo il blocco di lettura, o solo il blocco di scrittura, nell'annotazione @GuardedBy? FindBugs o altri strumenti supportano anche ReadWriteLock in @GuardedBy?@GuardedBy annotazione con java.util.concurrent.locks.ReadWriteLock

risposta

28

Al momento in cui scriviamo, @GuardedByisn't fully implemented by Findbugs, ed è per lo più solo per documentazione. (È parzialmente implementato.)

Io uso sempre @GuardedBy("readwritelock") o l'oggetto che uso per synchronize.

Ad esempio di quest'ultimo:

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

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

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

Grazie! Solo una breve nota, non conosco lo stato dell'arte di FindBugs (quindi ho posto questa domanda! :), ma il link che indica che l'annotazione potrebbe non essere implementata sembra avere quattro anni. –

+0

Questo progetto è molto attivo, a giudicare dall'attività sul bug-tracker collegato. –

+0

Intendi il progetto FindBugs? Oh certo, è vivo e vegeto. Intendevo la dichiarazione specifica di quattro anni fa che l'annotazione di GuardedBy potrebbe non essere implementata. Sto dicendo che il codice più recente di FindBugs potrebbe averlo implementato. Scusa se ho letto male/frainteso qualcosa. –

2

trovare bug supporta le seguenti annotazioni:

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

utilizzo di questi GuardedBy annotazioni dovrebbe essere la seguente:

@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

Queste annotazioni sono anche catturato in JSR305. Possono essere visti in questa implementazione di riferimento: http://code.google.com/p/jsr-305/source/browse/trunk/ri/src/main/java/javax/annotation/concurrent/ –

+3

Il nome del il blocco può essere scritto in modo più compatto come questo: @GuardedBy ("readWriteLock") - la porzione "value =" non è esplicitamente richiesta. –

+1

La mia domanda non riguarda l'utilizzo di base. Sto cercando di capire se un java.util.concurrent.locks.ReadWriteLock, che contiene sia un blocco di lettura che un blocco di scrittura, deve essere indicato in un'annotazione @GuardedBy come l'intero ReadWriteLock o dall'individuo in lettura e scrittura serrature. E se tutto ciò è efficace. –