Java並行処理プログラミングのアノテーション

「Java並行処理プログラミング」で書かれていたアノテーションを使う方法。
Maven2 でこういう dependency を定義。以上。現時点ではマーキング以上の意味はありませんが。

  net.jcip
  jcip-annotations
  1.0

以下 JavaDoc を引用。

net.jcip.annotations.GuardedBy

対象: FIELD, METHOD

The field or method to which this annotation is applied can only be accessed when holding a particular lock, which may be a built-in (synchronization) lock, or may be an explicit java.util.concurrent.Lock.

The argument determines which lock guards the annotated field or method:

• 
  this : The intrinsic lock of the object in whose class
  the field is defined.
• 
  class-name.this : For inner classes, it may be necessary
  to disambiguate 'this'; the class-name.this designation allows
  you to specify which 'this' reference is intended
• 
  itself : For reference fields only; the object to which
  the field refers.
• 
  field-name : The lock object is referenced by the
  (instance or static) field specified by field-name.
• 
  class-name.field-name : The lock object is reference by
  the static field specified by class-name.field-name.
• 
  method-name() : The lock object is returned by calling
  the named nil-ary method.
• 
  class-name.class : The Class object for the specified
  class should be used as the lock object.

net.jcip.annotations.Immutable

対象: TYPE

The class to which this annotation is applied is immutable. This means that its state cannot be seen to change by callers, which implies that

• all public fields are final,
• all public final reference fields refer to other immutable objects,
  and
• constructors and methods do not publish references to any internal
  state which is potentially mutable by the implementation.

Immutable objects may still have internal mutable state for purposes of performance optimization; some state variables may be lazily computed, so long as they are computed from immutable state and that callers cannot tell the difference.

Immutable objects are inherently thread-safe; they may be passed between threads or published without synchronization.

net.jcip.annotations.ThreadSafe

対象: TYPE

The class to which this annotation is applied is thread-safe. This means that no sequences of accesses (reads and writes to public fields, calls to public methods) may put the object into an invalid state, regardless of the interleaving of those actions by the runtime, and without requiring any additional synchronization or coordination on the part of the caller.

net.jcip.annotations.NotThreadSafe

対象: TYPE

The class to which this annotation is applied is not thread-safe. This annotation primarily exists for clarifying the non-thread-safety of a class that might otherwise be assumed to be thread-safe, despite the fact that it is a bad idea to assume a class is thread-safe without good reason.