7117360: Warnings in java.util.concurrent.atomic package

Reviewed-by: chegar, dholmes

11 files changed, 35 insertions, 40 deletions

diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java b/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java
index c21df7bab..a4d6d8297 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java
@@ -54,10 +54,10 @@ public class AtomicBoolean implements java.io.Serializable {
     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;
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java b/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java
index ec68acd78..1bc7fa2aa 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java
@@ -57,10 +57,10 @@ public class AtomicInteger extends Number implements java.io.Serializable {
     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 @@ public class AtomicInteger extends Number implements java.io.Serializable {
 
 
     /**
-     * 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();
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java b/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java
index 462270198..9928e5974 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java
@@ -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.
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java b/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
index aed5d1fc1..9f4fee4aa 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
@@ -135,7 +135,6 @@ public abstract class  AtomicIntegerFieldUpdater<T> {
      */
     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 @@ public abstract class  AtomicIntegerFieldUpdater<T> {
         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 @@ public abstract class  AtomicIntegerFieldUpdater<T> {
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != int.class)
                 throw new IllegalArgumentException("Must be integer type");
 
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicLong.java b/src/share/classes/java/util/concurrent/atomic/AtomicLong.java
index bf2c71a34..f503d577d 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicLong.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicLong.java
@@ -71,10 +71,10 @@ public class AtomicLong extends Number implements java.io.Serializable {
     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 @@ public class AtomicLong extends Number implements java.io.Serializable {
     }
 
     /**
-     * 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 @@ public class AtomicLong extends Number implements java.io.Serializable {
     }
 
     /**
-     * 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() {
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java b/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java
index ece5b6ad9..856ab39e0 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java
@@ -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 @@ public class AtomicLongArray implements java.io.Serializable {
         unsafe.putOrderedLong(array, checkedByteOffset(i), newValue);
     }
 
-
     /**
      * Atomically sets the element at position {@code i} to the given value
      * and returns the old value.
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java b/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
index fa0a85715..ccc5acbfe 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
@@ -265,11 +265,11 @@ public abstract class  AtomicLongFieldUpdater<T> {
         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 @@ public abstract class  AtomicLongFieldUpdater<T> {
                 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 @@ public abstract class  AtomicLongFieldUpdater<T> {
         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 @@ public abstract class  AtomicLongFieldUpdater<T> {
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != long.class)
                 throw new IllegalArgumentException("Must be long type");
 
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicReference.java b/src/share/classes/java/util/concurrent/atomic/AtomicReference.java
index 3178ca157..978664e2d 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicReference.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicReference.java
@@ -51,10 +51,10 @@ public class AtomicReference<V>  implements java.io.Serializable {
     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;
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java b/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java
index b173f2680..d92bdb5f2 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java
@@ -113,6 +113,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
         return getRaw(checkedByteOffset(i));
     }
 
+    @SuppressWarnings("unchecked")
     private E getRaw(long offset) {
         return (E) unsafe.getObjectVolatile(array, offset);
     }
@@ -150,7 +151,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
     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;
         }
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java b/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
index 7b72f0ff4..f2e0118aa 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
@@ -183,7 +183,7 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
         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 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
                                         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 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
             unsafe.putOrderedObject(obj, offset, newValue);
         }
 
+        @SuppressWarnings("unchecked")
         public V get(T obj) {
             if (obj == null || obj.getClass() != tclass || cclass != null)
                 targetCheck(obj);
diff --git a/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java b/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java
index 90aa3a0c5..5f8f1a03d 100644
--- a/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java
+++ b/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java
@@ -155,7 +155,6 @@ public class AtomicStampedReference<V> {
              casPair(current, Pair.of(newReference, newStamp)));
     }
 
-
     /**
      * Unconditionally sets the value of both the reference and stamp.
      *