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;
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;

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;
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();

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

@ -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.

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);
/**
* 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");

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();
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() {

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

@ -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.

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 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");

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;
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;

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));
}
@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;
}

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 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);

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)));
}
/**
* Unconditionally sets the value of both the reference and stamp.
*