--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java	Mon Dec 05 13:58:44 2011 +0000
@@ -54,10 +54,10 @@
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicBoolean.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicBoolean.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile int value;

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java	Mon Dec 05 13:58:44 2011 +0000
@@ -57,10 +57,10 @@
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicInteger.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicInteger.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile int value;
@@ -247,8 +247,7 @@
 
 
     /**
-     * Returns the value of this {@code AtomicInteger} as an
-     * {@code int}.
+     * Returns the value of this {@code AtomicInteger} as an {@code int}.
      */
     public int intValue() {
         return get();

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java	Mon Dec 05 13:58:44 2011 +0000
@@ -35,7 +35,6 @@
 
 package java.util.concurrent.atomic;
 import sun.misc.Unsafe;
-import java.util.*;
 
 /**
  * An {@code int} array in which elements may be updated atomically.

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java	Mon Dec 05 13:58:44 2011 +0000
@@ -135,7 +135,6 @@
      */
     public abstract void lazySet(T obj, int newValue);
 
-
     /**
      * Gets the current value held in the field of the given object managed
      * by this updater.
@@ -266,11 +265,11 @@
         private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -283,7 +282,7 @@
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != int.class)
                 throw new IllegalArgumentException("Must be integer type");
 

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLong.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLong.java	Mon Dec 05 13:58:44 2011 +0000
@@ -71,10 +71,10 @@
     private static native boolean VMSupportsCS8();
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicLong.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicLong.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile long value;
@@ -270,8 +270,7 @@
     }
 
     /**
-     * Returns the value of this {@code AtomicLong} as a {@code long}
-     * value.
+     * Returns the value of this {@code AtomicLong} as a {@code long}.
      */
     public long longValue() {
         return get();
@@ -287,8 +286,8 @@
     }
 
     /**
-     * Returns the value of this {@code AtomicLong} as a {@code
-     * double} after a widening primitive conversion.
+     * Returns the value of this {@code AtomicLong} as a {@code double}
+     * after a widening primitive conversion.
      * @jls 5.1.2 Widening Primitive Conversions
      */
     public double doubleValue() {

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java	Mon Dec 05 13:58:44 2011 +0000
@@ -35,7 +35,6 @@
 
 package java.util.concurrent.atomic;
 import sun.misc.Unsafe;
-import java.util.*;
 
 /**
  * A {@code long} array in which elements may be updated atomically.
@@ -136,7 +135,6 @@
         unsafe.putOrderedLong(array, checkedByteOffset(i), newValue);
     }
 
-
     /**
      * Atomically sets the element at position {@code i} to the given value
      * and returns the old value.

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java	Mon Dec 05 13:58:44 2011 +0000
@@ -265,11 +265,11 @@
         private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         CASUpdater(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -282,7 +282,7 @@
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != long.class)
                 throw new IllegalArgumentException("Must be long type");
 
@@ -348,11 +348,11 @@
         private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         LockedUpdater(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -365,7 +365,7 @@
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != long.class)
                 throw new IllegalArgumentException("Must be long type");
 

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReference.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReference.java	Mon Dec 05 13:58:44 2011 +0000
@@ -51,10 +51,10 @@
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicReference.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicReference.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile V value;

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java	Mon Dec 05 13:58:44 2011 +0000
@@ -113,6 +113,7 @@
         return getRaw(checkedByteOffset(i));
     }
 
+    @SuppressWarnings("unchecked")
     private E getRaw(long offset) {
         return (E) unsafe.getObjectVolatile(array, offset);
     }
@@ -150,7 +151,7 @@
     public final E getAndSet(int i, E newValue) {
         long offset = checkedByteOffset(i);
         while (true) {
-            E current = (E) getRaw(offset);
+            E current = getRaw(offset);
             if (compareAndSetRaw(offset, current, newValue))
                 return current;
         }

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java	Mon Dec 05 13:58:44 2011 +0000
@@ -183,7 +183,7 @@
         private final long offset;
         private final Class<T> tclass;
         private final Class<V> vclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         /*
          * Internal type checks within all update methods contain
@@ -201,8 +201,8 @@
                                         Class<V> vclass,
                                         String fieldName) {
             Field field = null;
-            Class fieldClass = null;
-            Class caller = null;
+            Class<?> fieldClass = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -280,6 +280,7 @@
             unsafe.putOrderedObject(obj, offset, newValue);
         }
 
+        @SuppressWarnings("unchecked")
         public V get(T obj) {
             if (obj == null || obj.getClass() != tclass || cclass != null)
                 targetCheck(obj);

--- a/jdk/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java	Mon Dec 05 12:24:17 2011 +0000
+++ b/jdk/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java	Mon Dec 05 13:58:44 2011 +0000
@@ -155,7 +155,6 @@
              casPair(current, Pair.of(newReference, newStamp)));
     }
 
-
     /**
      * Unconditionally sets the value of both the reference and stamp.
      *