stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Reviewed-by: chegar, dholmes
This commit is contained in:
Doug Lea 2011-12-05 13:58:44 +00:00
parent 226dc93377
commit c5cb5b2ac5
11 changed files with 35 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
jdk/src/share/classes/java/util/concurrent/atomic/AtomicBoolean.java
View File

@ -54,10 +54,10 @@ public class AtomicBoolean implements java.io.Serializable {
private static final long valueOffset; private static final long valueOffset;
static { static {
try { try {
valueOffset = unsafe.objectFieldOffset valueOffset = unsafe.objectFieldOffset
(AtomicBoolean.class.getDeclaredField("value")); (AtomicBoolean.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); } } catch (Exception ex) { throw new Error(ex); }
} }
private volatile int value; private volatile int value;

11
jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java
View File

@ -57,10 +57,10 @@ public class AtomicInteger extends Number implements java.io.Serializable {
private static final long valueOffset; private static final long valueOffset;
static { static {
try { try {
valueOffset = unsafe.objectFieldOffset valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value")); (AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); } } catch (Exception ex) { throw new Error(ex); }
} }
private volatile int value; 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 * Returns the value of this {@code AtomicInteger} as an {@code int}.
* {@code int}.
*/ */
public int intValue() { public int intValue() {
return get(); return get();

1
jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java
View File

@ -35,7 +35,6 @@
package java.util.concurrent.atomic; package java.util.concurrent.atomic;
import sun.misc.Unsafe; import sun.misc.Unsafe;
import java.util.*;
/** /**
* An {@code int} array in which elements may be updated atomically. * An {@code int} array in which elements may be updated atomically.

7
jdk/src/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
View File

@ -135,7 +135,6 @@ public abstract class AtomicIntegerFieldUpdater<T> {
*/ */
public abstract void lazySet(T obj, int newValue); public abstract void lazySet(T obj, int newValue);
/** /**
* Gets the current value held in the field of the given object managed * Gets the current value held in the field of the given object managed
* by this updater. * by this updater.
@ -266,11 +265,11 @@ public abstract class AtomicIntegerFieldUpdater<T> {
private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final Unsafe unsafe = Unsafe.getUnsafe();
private final long offset; private final long offset;
private final Class<T> tclass; private final Class<T> tclass;
private final Class cclass; private final Class<?> cclass;
AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName) { AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName) {
Field field = null; Field field = null;
Class caller = null; Class<?> caller = null;
int modifiers = 0; int modifiers = 0;
try { try {
field = tclass.getDeclaredField(fieldName); field = tclass.getDeclaredField(fieldName);
@ -283,7 +282,7 @@ public abstract class AtomicIntegerFieldUpdater<T> {
throw new RuntimeException(ex); throw new RuntimeException(ex);
} }
Class fieldt = field.getType(); Class<?> fieldt = field.getType();
if (fieldt != int.class) if (fieldt != int.class)
throw new IllegalArgumentException("Must be integer type"); throw new IllegalArgumentException("Must be integer type");

15
jdk/src/share/classes/java/util/concurrent/atomic/AtomicLong.java
View File

@ -71,10 +71,10 @@ public class AtomicLong extends Number implements java.io.Serializable {
private static native boolean VMSupportsCS8(); private static native boolean VMSupportsCS8();
static { static {
try { try {
valueOffset = unsafe.objectFieldOffset valueOffset = unsafe.objectFieldOffset
(AtomicLong.class.getDeclaredField("value")); (AtomicLong.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); } } catch (Exception ex) { throw new Error(ex); }
} }
private volatile long value; 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} * Returns the value of this {@code AtomicLong} as a {@code long}.
* value.
*/ */
public long longValue() { public long longValue() {
return get(); 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 * Returns the value of this {@code AtomicLong} as a {@code double}
* double} after a widening primitive conversion. * after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions * @jls 5.1.2 Widening Primitive Conversions
*/ */
public double doubleValue() { public double doubleValue() {

2
jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongArray.java
View File

@ -35,7 +35,6 @@
package java.util.concurrent.atomic; package java.util.concurrent.atomic;
import sun.misc.Unsafe; import sun.misc.Unsafe;
import java.util.*;
/** /**
* A {@code long} array in which elements may be updated atomically. * 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); unsafe.putOrderedLong(array, checkedByteOffset(i), newValue);
} }
/** /**
* Atomically sets the element at position {@code i} to the given value * Atomically sets the element at position {@code i} to the given value
* and returns the old value. * and returns the old value.

12
jdk/src/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
View File

@ -265,11 +265,11 @@ public abstract class AtomicLongFieldUpdater<T> {
private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final Unsafe unsafe = Unsafe.getUnsafe();
private final long offset; private final long offset;
private final Class<T> tclass; private final Class<T> tclass;
private final Class cclass; private final Class<?> cclass;
CASUpdater(Class<T> tclass, String fieldName) { CASUpdater(Class<T> tclass, String fieldName) {
Field field = null; Field field = null;
Class caller = null; Class<?> caller = null;
int modifiers = 0; int modifiers = 0;
try { try {
field = tclass.getDeclaredField(fieldName); field = tclass.getDeclaredField(fieldName);
@ -282,7 +282,7 @@ public abstract class AtomicLongFieldUpdater<T> {
throw new RuntimeException(ex); throw new RuntimeException(ex);
} }
Class fieldt = field.getType(); Class<?> fieldt = field.getType();
if (fieldt != long.class) if (fieldt != long.class)
throw new IllegalArgumentException("Must be long type"); throw new IllegalArgumentException("Must be long type");
@ -348,11 +348,11 @@ public abstract class AtomicLongFieldUpdater<T> {
private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final Unsafe unsafe = Unsafe.getUnsafe();
private final long offset; private final long offset;
private final Class<T> tclass; private final Class<T> tclass;
private final Class cclass; private final Class<?> cclass;
LockedUpdater(Class<T> tclass, String fieldName) { LockedUpdater(Class<T> tclass, String fieldName) {
Field field = null; Field field = null;
Class caller = null; Class<?> caller = null;
int modifiers = 0; int modifiers = 0;
try { try {
field = tclass.getDeclaredField(fieldName); field = tclass.getDeclaredField(fieldName);
@ -365,7 +365,7 @@ public abstract class AtomicLongFieldUpdater<T> {
throw new RuntimeException(ex); throw new RuntimeException(ex);
} }
Class fieldt = field.getType(); Class<?> fieldt = field.getType();
if (fieldt != long.class) if (fieldt != long.class)
throw new IllegalArgumentException("Must be long type"); throw new IllegalArgumentException("Must be long type");

8
jdk/src/share/classes/java/util/concurrent/atomic/AtomicReference.java
View File

@ -51,10 +51,10 @@ public class AtomicReference<V> implements java.io.Serializable {
private static final long valueOffset; private static final long valueOffset;
static { static {
try { try {
valueOffset = unsafe.objectFieldOffset valueOffset = unsafe.objectFieldOffset
(AtomicReference.class.getDeclaredField("value")); (AtomicReference.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); } } catch (Exception ex) { throw new Error(ex); }
} }
private volatile V value; private volatile V value;

3
jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java
View File

@ -113,6 +113,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
return getRaw(checkedByteOffset(i)); return getRaw(checkedByteOffset(i));
} }
@SuppressWarnings("unchecked")
private E getRaw(long offset) { private E getRaw(long offset) {
return (E) unsafe.getObjectVolatile(array, 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) { public final E getAndSet(int i, E newValue) {
long offset = checkedByteOffset(i); long offset = checkedByteOffset(i);
while (true) { while (true) {
E current = (E) getRaw(offset); E current = getRaw(offset);
if (compareAndSetRaw(offset, current, newValue)) if (compareAndSetRaw(offset, current, newValue))
return current; return current;
} }

7
jdk/src/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
View File

@ -183,7 +183,7 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
private final long offset; private final long offset;
private final Class<T> tclass; private final Class<T> tclass;
private final Class<V> vclass; private final Class<V> vclass;
private final Class cclass; private final Class<?> cclass;
/* /*
* Internal type checks within all update methods contain * Internal type checks within all update methods contain
@ -201,8 +201,8 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
Class<V> vclass, Class<V> vclass,
String fieldName) { String fieldName) {
Field field = null; Field field = null;
Class fieldClass = null; Class<?> fieldClass = null;
Class caller = null; Class<?> caller = null;
int modifiers = 0; int modifiers = 0;
try { try {
field = tclass.getDeclaredField(fieldName); field = tclass.getDeclaredField(fieldName);
@ -280,6 +280,7 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
unsafe.putOrderedObject(obj, offset, newValue); unsafe.putOrderedObject(obj, offset, newValue);
} }
@SuppressWarnings("unchecked")
public V get(T obj) { public V get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null) if (obj == null || obj.getClass() != tclass || cclass != null)
targetCheck(obj); targetCheck(obj);

1
jdk/src/share/classes/java/util/concurrent/atomic/AtomicStampedReference.java
View File

@ -155,7 +155,6 @@ public class AtomicStampedReference<V> {
casPair(current, Pair.of(newReference, newStamp))); casPair(current, Pair.of(newReference, newStamp)));
} }
/** /**
* Unconditionally sets the value of both the reference and stamp. * Unconditionally sets the value of both the reference and stamp.
* *