diff --git a/common/source/java/ch/systemsx/cisd/common/annotation/GuardedBy.java b/common/source/java/ch/systemsx/cisd/common/annotation/GuardedBy.java
index 8f6c0c8a81d63a05fbc35d0181e6e5746c2fdb2f..ef6ab2770bb4c357a1628d5fa86f141e42018641 100644
--- a/common/source/java/ch/systemsx/cisd/common/annotation/GuardedBy.java
+++ b/common/source/java/ch/systemsx/cisd/common/annotation/GuardedBy.java
@@ -1,17 +1,11 @@
 /*
- * Copyright 2007 ETH Zuerich, CISD
+ * Copyright (c) 2005 Brian Goetz and Tim Peierls
+ * Released under the Creative Commons Attribution License
+ *   (http://creativecommons.org/licenses/by/2.5)
+ * Official home: http://www.jcip.net
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Any republication or derived work distributed in source code form
+ * must include this copyright and license notice.
  */
 
 package ch.systemsx.cisd.common.annotation;
@@ -22,23 +16,38 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * 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:
+ * 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:
  * <ul>
- * <li><code>this</code>: The intrinsic lock of the object in whose class the field is defined.</li>
- * <li><code>class-name.this</code>: For inner classes, it may be necessary to disambiguate 'this'; the
- * <em>class-name.this</em> designation allows you to specify which 'this' reference is intended</li>
- * <li><code>itself</code>: For reference fields only; the object to which the field refers.</li>
- * <li><code>field-name</code>: The lock object is referenced by the (instance or static) field specified by
- * <em>field-name</em>.</li>
- * <li><code>class-name.field-name</code>: The lock object is reference by the static field specified by
- * <em>class-name.field-name</em>.</li>
- * <li><code>method-name()</code> : The lock object is returned by calling the named nil-ary method. </li>
- * <li> <code>class-name.class</code> : The Class object for the specified class should be used as the lock object.
+ * <li>
+ * <code>this</code> : The intrinsic lock of the object in whose class the field is defined.
+ * </li>
+ * <li>
+ * <code>class-name.this</code> : For inner classes, it may be necessary to disambiguate 'this';
+ * the <em>class-name.this</em> designation allows you to specify which 'this' reference is intended
+ * </li>
+ * <li>
+ * <code>itself</code> : For reference fields only; the object to which the field refers.
+ * </li>
+ * <li>
+ * <code>field-name</code> : The lock object is referenced by the (instance or static) field
+ * specified by <em>field-name</em>.
+ * </li>
+ * <li>
+ * <code>class-name.field-name</code> : The lock object is reference by the static field specified
+ * by <em>class-name.field-name</em>.
+ * </li>
+ * <li>
+ * <code>method-name()</code> : The lock object is returned by calling the named nil-ary method.
+ * </li>
+ * <li>
+ * <code>class-name.class</code> : The Class object for the specified class should be used as the lock object.
  * </li>
  * 
- * @author Christian Ribeaud
+ * @author <a href="http://www.javaconcurrencyinpractice.com/">http://www.javaconcurrencyinpractice.com/</a>
  */
 @Target(
     { ElementType.FIELD, ElementType.METHOD })
diff --git a/common/source/java/ch/systemsx/cisd/common/annotation/NotThreadSafe.java b/common/source/java/ch/systemsx/cisd/common/annotation/NotThreadSafe.java
new file mode 100644
index 0000000000000000000000000000000000000000..30edb74cfe27595681e086a5feb1f5d3638fcbb9
--- /dev/null
+++ b/common/source/java/ch/systemsx/cisd/common/annotation/NotThreadSafe.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2005 Brian Goetz and Tim Peierls
+ * Released under the Creative Commons Attribution License
+ *   (http://creativecommons.org/licenses/by/2.5)
+ * Official home: http://www.jcip.net
+ *
+ * Any republication or derived work distributed in source code form
+ * must include this copyright and license notice.
+ */
+package ch.systemsx.cisd.common.annotation;
+
+import java.lang.annotation.*;
+
+/**
+ * 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.
+ * 
+ * @see ThreadSafe
+ */
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface NotThreadSafe
+{
+}
diff --git a/common/source/java/ch/systemsx/cisd/common/annotation/ThreadSafe.java b/common/source/java/ch/systemsx/cisd/common/annotation/ThreadSafe.java
index 2d78e5544477e57928d91e2e389e812618ae3381..8c97ef2218e0919a8cdd2df553a0a5f2c4f70400 100644
--- a/common/source/java/ch/systemsx/cisd/common/annotation/ThreadSafe.java
+++ b/common/source/java/ch/systemsx/cisd/common/annotation/ThreadSafe.java
@@ -23,12 +23,13 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * 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.
+ * 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.
  * 
- * @author Christian Ribeaud
+ * @author <a href="http://www.javaconcurrencyinpractice.com/">http://www.javaconcurrencyinpractice.com/</a>
  */
 @Documented
 @Target(ElementType.TYPE)