concurrent/atomic/AtomicLongFieldUpdater.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent.atomic;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;

/**
 * A reflection-based utility that enables atomic updates to
 * designated {@code volatile long} fields of designated classes.
 * This class is designed for use in atomic data structures in which
 * several fields of the same node are independently subject to atomic
 * updates.
 *
 * <p>Note that the guarantees of the {@code compareAndSet}
 * method in this class are weaker than in other atomic classes.
 * Because this class cannot ensure that all uses of the field
 * are appropriate for purposes of atomic access, it can
 * guarantee atomicity only with respect to other invocations of
 * {@code compareAndSet} and {@code set} on the same updater.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <T> The type of the object holding the updatable field
 */
public abstract class AtomicLongFieldUpdater<T> {
    /**
     * Creates and returns an updater for objects with the given field.
     * The Class argument is needed to check that reflective types and
     * generic types match.
     *
     * @param tclass the class of the objects holding the field
     * @param fieldName the name of the field to be updated
     * @param <U> the type of instances of tclass
     * @return the updater
     * @throws IllegalArgumentException if the field is not a
     * volatile long type
     * @throws RuntimeException with a nested reflection-based
     * exception if the class does not hold field or is the wrong type,
     * or the field is inaccessible to the caller according to Java language
     * access control
     */
    @CallerSensitive
    public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass,
                                                           String fieldName) {
        Class<?> caller = Reflection.getCallerClass();
        if (AtomicLong.VM_SUPPORTS_LONG_CAS)
            return new CASUpdater<U>(tclass, fieldName, caller);
        else
            return new LockedUpdater<U>(tclass, fieldName, caller);
    }

    /**
     * Protected do-nothing constructor for use by subclasses.
     */
    protected AtomicLongFieldUpdater() {
    }

    /**
     * Atomically sets the field of the given object managed by this updater
     * to the given updated value if the current value {@code ==} the
     * expected value. This method is guaranteed to be atomic with respect to
     * other calls to {@code compareAndSet} and {@code set}, but not
     * necessarily with respect to other changes in the field.
     *
     * @param obj An object whose field to conditionally set
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful
     * @throws ClassCastException if {@code obj} is not an instance
     * of the class possessing the field established in the constructor
     */
    public abstract boolean compareAndSet(T obj, long expect, long update);

    /**
     * Atomically sets the field of the given object managed by this updater
     * to the given updated value if the current value {@code ==} the
     * expected value. This method is guaranteed to be atomic with respect to
     * other calls to {@code compareAndSet} and {@code set}, but not
     * necessarily with respect to other changes in the field.
     *
     * <p><a href="package-summary.html#weakCompareAndSet">May fail
     * spuriously and does not provide ordering guarantees</a>, so is
     * only rarely an appropriate alternative to {@code compareAndSet}.
     *
     * @param obj An object whose field to conditionally set
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful
     * @throws ClassCastException if {@code obj} is not an instance
     * of the class possessing the field established in the constructor
     */
    public abstract boolean weakCompareAndSet(T obj, long expect, long update);

    /**
     * Sets the field of the given object managed by this updater to the
     * given updated value. This operation is guaranteed to act as a volatile
     * store with respect to subsequent invocations of {@code compareAndSet}.
     *
     * @param obj An object whose field to set
     * @param newValue the new value
     */
    public abstract void set(T obj, long newValue);

    /**
     * Eventually sets the field of the given object managed by this
     * updater to the given updated value.
     *
     * @param obj An object whose field to set
     * @param newValue the new value
     * @since 1.6
     */
    public abstract void lazySet(T obj, long newValue);

    /**
     * Gets the current value held in the field of the given object managed
     * by this updater.
     *
     * @param obj An object whose field to get
     * @return the current value
     */
    public abstract long get(T obj);

    /**
     * Atomically sets the field of the given object managed by this updater
     * to the given value and returns the old value.
     *
     * @param obj An object whose field to get and set
     * @param newValue the new value
     * @return the previous value
     */
    public long getAndSet(T obj, long newValue) {
        long prev;
        do {
            prev = get(obj);
        } while (!compareAndSet(obj, prev, newValue));
        return prev;
    }

    /**
     * Atomically increments by one the current value of the field of the
     * given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @return the previous value
     */
    public long getAndIncrement(T obj) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev + 1;
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

    /**
     * Atomically decrements by one the current value of the field of the
     * given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @return the previous value
     */
    public long getAndDecrement(T obj) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev - 1;
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

    /**
     * Atomically adds the given value to the current value of the field of
     * the given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @param delta the value to add
     * @return the previous value
     */
    public long getAndAdd(T obj, long delta) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev + delta;
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

    /**
     * Atomically increments by one the current value of the field of the
     * given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @return the updated value
     */
    public long incrementAndGet(T obj) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev + 1;
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

    /**
     * Atomically decrements by one the current value of the field of the
     * given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @return the updated value
     */
    public long decrementAndGet(T obj) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev - 1;
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

    /**
     * Atomically adds the given value to the current value of the field of
     * the given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @param delta the value to add
     * @return the updated value
     */
    public long addAndGet(T obj, long delta) {
        long prev, next;
        do {
            prev = get(obj);
            next = prev + delta;
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

    /**
     * Atomically updates the field of the given object managed by this updater
     * with the results of applying the given function, returning the previous
     * value. The function should be side-effect-free, since it may be
     * re-applied when attempted updates fail due to contention among threads.
     *
     * @param obj An object whose field to get and set
     * @param updateFunction a side-effect-free function
     * @return the previous value
     * @since 1.8
     */
    public final long getAndUpdate(T obj, LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get(obj);
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

    /**
     * Atomically updates the field of the given object managed by this updater
     * with the results of applying the given function, returning the updated
     * value. The function should be side-effect-free, since it may be
     * re-applied when attempted updates fail due to contention among threads.
     *
     * @param obj An object whose field to get and set
     * @param updateFunction a side-effect-free function
     * @return the updated value
     * @since 1.8
     */
    public final long updateAndGet(T obj, LongUnaryOperator updateFunction) {
        long prev, next;
        do {
            prev = get(obj);
            next = updateFunction.applyAsLong(prev);
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

    /**
     * Atomically updates the field of the given object managed by this
     * updater with the results of applying the given function to the
     * current and given values, returning the previous value. The
     * function should be side-effect-free, since it may be re-applied
     * when attempted updates fail due to contention among threads.  The
     * function is applied with the current value as its first argument,
     * and the given update as the second argument.
     *
     * @param obj An object whose field to get and set
     * @param x the update value
     * @param accumulatorFunction a side-effect-free function of two arguments
     * @return the previous value
     * @since 1.8
     */
    public final long getAndAccumulate(T obj, long x,
                                       LongBinaryOperator accumulatorFunction) {
        long prev, next;
        do {
            prev = get(obj);
            next = accumulatorFunction.applyAsLong(prev, x);
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

    /**
     * Atomically updates the field of the given object managed by this
     * updater with the results of applying the given function to the
     * current and given values, returning the updated value. The
     * function should be side-effect-free, since it may be re-applied
     * when attempted updates fail due to contention among threads.  The
     * function is applied with the current value as its first argument,
     * and the given update as the second argument.
     *
     * @param obj An object whose field to get and set
     * @param x the update value
     * @param accumulatorFunction a side-effect-free function of two arguments
     * @return the updated value
     * @since 1.8
     */
    public final long accumulateAndGet(T obj, long x,
                                       LongBinaryOperator accumulatorFunction) {
        long prev, next;
        do {
            prev = get(obj);
            next = accumulatorFunction.applyAsLong(prev, x);
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

    private static final class CASUpdater<T> extends AtomicLongFieldUpdater<T> {
        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
        private final long offset;
        /**
         * if field is protected, the subclass constructing updater, else
         * the same as tclass
         */
        private final Class<?> cclass;
        /** class holding the field */
        private final Class<T> tclass;

        CASUpdater(final Class<T> tclass, final String fieldName,
                   final Class<?> caller) {
            final Field field;
            final int modifiers;
            try {
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                modifiers = field.getModifiers();
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                ClassLoader cl = tclass.getClassLoader();
                ClassLoader ccl = caller.getClassLoader();
                if ((ccl != null) && (ccl != cl) &&
                    ((cl == null) || !isAncestor(cl, ccl))) {
                    sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                }
            } catch (PrivilegedActionException pae) {
                throw new RuntimeException(pae.getException());
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }

            if (field.getType() != long.class)
                throw new IllegalArgumentException("Must be long type");

            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

            this.cclass = (Modifier.isProtected(modifiers)) ? caller : tclass;
            this.tclass = tclass;
            this.offset = U.objectFieldOffset(field);
        }

        /**
         * Checks that target argument is instance of cclass.  On
         * failure, throws cause.
         */
        private final void accessCheck(T obj) {
            if (!cclass.isInstance(obj))
                throwAccessCheckException(obj);
        }

        /**
         * Throws access exception if accessCheck failed due to
         * protected access, else ClassCastException.
         */
        private final void throwAccessCheckException(T obj) {
            if (cclass == tclass)
                throw new ClassCastException();
            else
                throw new RuntimeException(
                    new IllegalAccessException(
                        "Class " +
                        cclass.getName() +
                        " can not access a protected member of class " +
                        tclass.getName() +
                        " using an instance of " +
                        obj.getClass().getName()));
        }

        public final boolean compareAndSet(T obj, long expect, long update) {
            accessCheck(obj);
            return U.compareAndSwapLong(obj, offset, expect, update);
        }

        public final boolean weakCompareAndSet(T obj, long expect, long update) {
            accessCheck(obj);
            return U.compareAndSwapLong(obj, offset, expect, update);
        }

        public final void set(T obj, long newValue) {
            accessCheck(obj);
            U.putLongVolatile(obj, offset, newValue);
        }

        public final void lazySet(T obj, long newValue) {
            accessCheck(obj);
            U.putOrderedLong(obj, offset, newValue);
        }

        public final long get(T obj) {
            accessCheck(obj);
            return U.getLongVolatile(obj, offset);
        }

        public final long getAndSet(T obj, long newValue) {
            accessCheck(obj);
            return U.getAndSetLong(obj, offset, newValue);
        }

        public final long getAndAdd(T obj, long delta) {
            accessCheck(obj);
            return U.getAndAddLong(obj, offset, delta);
        }

        public final long getAndIncrement(T obj) {
            return getAndAdd(obj, 1);
        }

        public final long getAndDecrement(T obj) {
            return getAndAdd(obj, -1);
        }

        public final long incrementAndGet(T obj) {
            return getAndAdd(obj, 1) + 1;
        }

        public final long decrementAndGet(T obj) {
            return getAndAdd(obj, -1) - 1;
        }

        public final long addAndGet(T obj, long delta) {
            return getAndAdd(obj, delta) + delta;
        }
    }

    private static final class LockedUpdater<T> extends AtomicLongFieldUpdater<T> {
        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
        private final long offset;
        /**
         * if field is protected, the subclass constructing updater, else
         * the same as tclass
         */
        private final Class<?> cclass;
        /** class holding the field */
        private final Class<T> tclass;

        LockedUpdater(final Class<T> tclass, final String fieldName,
                      final Class<?> caller) {
            Field field = null;
            int modifiers = 0;
            try {
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                modifiers = field.getModifiers();
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                ClassLoader cl = tclass.getClassLoader();
                ClassLoader ccl = caller.getClassLoader();
                if ((ccl != null) && (ccl != cl) &&
                    ((cl == null) || !isAncestor(cl, ccl))) {
                    sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                }
            } catch (PrivilegedActionException pae) {
                throw new RuntimeException(pae.getException());
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }

            if (field.getType() != long.class)
                throw new IllegalArgumentException("Must be long type");

            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

            this.cclass = (Modifier.isProtected(modifiers)) ? caller : tclass;
            this.tclass = tclass;
            this.offset = U.objectFieldOffset(field);
        }

        /**
         * Checks that target argument is instance of cclass.  On
         * failure, throws cause.
         */
        private final void accessCheck(T obj) {
            if (!cclass.isInstance(obj))
                throw accessCheckException(obj);
        }

        /**
         * Returns access exception if accessCheck failed due to
         * protected access, else ClassCastException.
         */
        private final RuntimeException accessCheckException(T obj) {
            if (cclass == tclass)
                return new ClassCastException();
            else
                return new RuntimeException(
                    new IllegalAccessException(
                        "Class " +
                        cclass.getName() +
                        " can not access a protected member of class " +
                        tclass.getName() +
                        " using an instance of " +
                        obj.getClass().getName()));
        }

        public final boolean compareAndSet(T obj, long expect, long update) {
            accessCheck(obj);
            synchronized (this) {
                long v = U.getLong(obj, offset);
                if (v != expect)
                    return false;
                U.putLong(obj, offset, update);
                return true;
            }
        }

        public final boolean weakCompareAndSet(T obj, long expect, long update) {
            return compareAndSet(obj, expect, update);
        }

        public final void set(T obj, long newValue) {
            accessCheck(obj);
            synchronized (this) {
                U.putLong(obj, offset, newValue);
            }
        }

        public final void lazySet(T obj, long newValue) {
            set(obj, newValue);
        }

        public final long get(T obj) {
            accessCheck(obj);
            synchronized (this) {
                return U.getLong(obj, offset);
            }
        }
    }

    /**
     * Returns true if the second classloader can be found in the first
     * classloader's delegation chain.
     * Equivalent to the inaccessible: first.isAncestor(second).
     */
    static boolean isAncestor(ClassLoader first, ClassLoader second) {
        ClassLoader acl = first;
        do {
            acl = acl.getParent();
            if (second == acl) {
                return true;
            }
        } while (acl != null);
        return false;
    }
}
Revision:	1.1
Committed:	Sat Mar 26 06:22:51 2016 UTC (8 years, 2 months ago) by jsr166
Branch:	MAIN
Log Message:	fork jdk8 maintenance branch for source and jtreg tests
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/publicdomain/zero/1.0/
5	*/
6
7	package java.util.concurrent.atomic;
8
9	import java.lang.reflect.Field;
10	import java.lang.reflect.Modifier;
11	import java.security.AccessController;
12	import java.security.PrivilegedActionException;
13	import java.security.PrivilegedExceptionAction;
14	import java.util.function.LongBinaryOperator;
15	import java.util.function.LongUnaryOperator;
16	import sun.reflect.CallerSensitive;
17	import sun.reflect.Reflection;
18
19	/**
20	* A reflection-based utility that enables atomic updates to
21	* designated {@code volatile long} fields of designated classes.
22	* This class is designed for use in atomic data structures in which
23	* several fields of the same node are independently subject to atomic
24	* updates.
25	*
26	* <p>Note that the guarantees of the {@code compareAndSet}
27	* method in this class are weaker than in other atomic classes.
28	* Because this class cannot ensure that all uses of the field
29	* are appropriate for purposes of atomic access, it can
30	* guarantee atomicity only with respect to other invocations of
31	* {@code compareAndSet} and {@code set} on the same updater.
32	*
33	* @since 1.5
34	* @author Doug Lea
35	* @param <T> The type of the object holding the updatable field
36	*/
37	public abstract class AtomicLongFieldUpdater<T> {
38	/**
39	* Creates and returns an updater for objects with the given field.
40	* The Class argument is needed to check that reflective types and
41	* generic types match.
42	*
43	* @param tclass the class of the objects holding the field
44	* @param fieldName the name of the field to be updated
45	* @param <U> the type of instances of tclass
46	* @return the updater
47	* @throws IllegalArgumentException if the field is not a
48	* volatile long type
49	* @throws RuntimeException with a nested reflection-based
50	* exception if the class does not hold field or is the wrong type,
51	* or the field is inaccessible to the caller according to Java language
52	* access control
53	*/
54	@CallerSensitive
55	public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass,
56	String fieldName) {
57	Class<?> caller = Reflection.getCallerClass();
58	if (AtomicLong.VM_SUPPORTS_LONG_CAS)
59	return new CASUpdater<U>(tclass, fieldName, caller);
60	else
61	return new LockedUpdater<U>(tclass, fieldName, caller);
62	}
63
64	/**
65	* Protected do-nothing constructor for use by subclasses.
66	*/
67	protected AtomicLongFieldUpdater() {
68	}
69
70	/**
71	* Atomically sets the field of the given object managed by this updater
72	* to the given updated value if the current value {@code ==} the
73	* expected value. This method is guaranteed to be atomic with respect to
74	* other calls to {@code compareAndSet} and {@code set}, but not
75	* necessarily with respect to other changes in the field.
76	*
77	* @param obj An object whose field to conditionally set
78	* @param expect the expected value
79	* @param update the new value
80	* @return {@code true} if successful
81	* @throws ClassCastException if {@code obj} is not an instance
82	* of the class possessing the field established in the constructor
83	*/
84	public abstract boolean compareAndSet(T obj, long expect, long update);
85
86	/**
87	* Atomically sets the field of the given object managed by this updater
88	* to the given updated value if the current value {@code ==} the
89	* expected value. This method is guaranteed to be atomic with respect to
90	* other calls to {@code compareAndSet} and {@code set}, but not
91	* necessarily with respect to other changes in the field.
92	*
93	* <p><a href="package-summary.html#weakCompareAndSet">May fail
94	* spuriously and does not provide ordering guarantees</a>, so is
95	* only rarely an appropriate alternative to {@code compareAndSet}.
96	*
97	* @param obj An object whose field to conditionally set
98	* @param expect the expected value
99	* @param update the new value
100	* @return {@code true} if successful
101	* @throws ClassCastException if {@code obj} is not an instance
102	* of the class possessing the field established in the constructor
103	*/
104	public abstract boolean weakCompareAndSet(T obj, long expect, long update);
105
106	/**
107	* Sets the field of the given object managed by this updater to the
108	* given updated value. This operation is guaranteed to act as a volatile
109	* store with respect to subsequent invocations of {@code compareAndSet}.
110	*
111	* @param obj An object whose field to set
112	* @param newValue the new value
113	*/
114	public abstract void set(T obj, long newValue);
115
116	/**
117	* Eventually sets the field of the given object managed by this
118	* updater to the given updated value.
119	*
120	* @param obj An object whose field to set
121	* @param newValue the new value
122	* @since 1.6
123	*/
124	public abstract void lazySet(T obj, long newValue);
125
126	/**
127	* Gets the current value held in the field of the given object managed
128	* by this updater.
129	*
130	* @param obj An object whose field to get
131	* @return the current value
132	*/
133	public abstract long get(T obj);
134
135	/**
136	* Atomically sets the field of the given object managed by this updater
137	* to the given value and returns the old value.
138	*
139	* @param obj An object whose field to get and set
140	* @param newValue the new value
141	* @return the previous value
142	*/
143	public long getAndSet(T obj, long newValue) {
144	long prev;
145	do {
146	prev = get(obj);
147	} while (!compareAndSet(obj, prev, newValue));
148	return prev;
149	}
150
151	/**
152	* Atomically increments by one the current value of the field of the
153	* given object managed by this updater.
154	*
155	* @param obj An object whose field to get and set
156	* @return the previous value
157	*/
158	public long getAndIncrement(T obj) {
159	long prev, next;
160	do {
161	prev = get(obj);
162	next = prev + 1;
163	} while (!compareAndSet(obj, prev, next));
164	return prev;
165	}
166
167	/**
168	* Atomically decrements by one the current value of the field of the
169	* given object managed by this updater.
170	*
171	* @param obj An object whose field to get and set
172	* @return the previous value
173	*/
174	public long getAndDecrement(T obj) {
175	long prev, next;
176	do {
177	prev = get(obj);
178	next = prev - 1;
179	} while (!compareAndSet(obj, prev, next));
180	return prev;
181	}
182
183	/**
184	* Atomically adds the given value to the current value of the field of
185	* the given object managed by this updater.
186	*
187	* @param obj An object whose field to get and set
188	* @param delta the value to add
189	* @return the previous value
190	*/
191	public long getAndAdd(T obj, long delta) {
192	long prev, next;
193	do {
194	prev = get(obj);
195	next = prev + delta;
196	} while (!compareAndSet(obj, prev, next));
197	return prev;
198	}
199
200	/**
201	* Atomically increments by one the current value of the field of the
202	* given object managed by this updater.
203	*
204	* @param obj An object whose field to get and set
205	* @return the updated value
206	*/
207	public long incrementAndGet(T obj) {
208	long prev, next;
209	do {
210	prev = get(obj);
211	next = prev + 1;
212	} while (!compareAndSet(obj, prev, next));
213	return next;
214	}
215
216	/**
217	* Atomically decrements by one the current value of the field of the
218	* given object managed by this updater.
219	*
220	* @param obj An object whose field to get and set
221	* @return the updated value
222	*/
223	public long decrementAndGet(T obj) {
224	long prev, next;
225	do {
226	prev = get(obj);
227	next = prev - 1;
228	} while (!compareAndSet(obj, prev, next));
229	return next;
230	}
231
232	/**
233	* Atomically adds the given value to the current value of the field of
234	* the given object managed by this updater.
235	*
236	* @param obj An object whose field to get and set
237	* @param delta the value to add
238	* @return the updated value
239	*/
240	public long addAndGet(T obj, long delta) {
241	long prev, next;
242	do {
243	prev = get(obj);
244	next = prev + delta;
245	} while (!compareAndSet(obj, prev, next));
246	return next;
247	}
248
249	/**
250	* Atomically updates the field of the given object managed by this updater
251	* with the results of applying the given function, returning the previous
252	* value. The function should be side-effect-free, since it may be
253	* re-applied when attempted updates fail due to contention among threads.
254	*
255	* @param obj An object whose field to get and set
256	* @param updateFunction a side-effect-free function
257	* @return the previous value
258	* @since 1.8
259	*/
260	public final long getAndUpdate(T obj, LongUnaryOperator updateFunction) {
261	long prev, next;
262	do {
263	prev = get(obj);
264	next = updateFunction.applyAsLong(prev);
265	} while (!compareAndSet(obj, prev, next));
266	return prev;
267	}
268
269	/**
270	* Atomically updates the field of the given object managed by this updater
271	* with the results of applying the given function, returning the updated
272	* value. The function should be side-effect-free, since it may be
273	* re-applied when attempted updates fail due to contention among threads.
274	*
275	* @param obj An object whose field to get and set
276	* @param updateFunction a side-effect-free function
277	* @return the updated value
278	* @since 1.8
279	*/
280	public final long updateAndGet(T obj, LongUnaryOperator updateFunction) {
281	long prev, next;
282	do {
283	prev = get(obj);
284	next = updateFunction.applyAsLong(prev);
285	} while (!compareAndSet(obj, prev, next));
286	return next;
287	}
288
289	/**
290	* Atomically updates the field of the given object managed by this
291	* updater with the results of applying the given function to the
292	* current and given values, returning the previous value. The
293	* function should be side-effect-free, since it may be re-applied
294	* when attempted updates fail due to contention among threads. The
295	* function is applied with the current value as its first argument,
296	* and the given update as the second argument.
297	*
298	* @param obj An object whose field to get and set
299	* @param x the update value
300	* @param accumulatorFunction a side-effect-free function of two arguments
301	* @return the previous value
302	* @since 1.8
303	*/
304	public final long getAndAccumulate(T obj, long x,
305	LongBinaryOperator accumulatorFunction) {
306	long prev, next;
307	do {
308	prev = get(obj);
309	next = accumulatorFunction.applyAsLong(prev, x);
310	} while (!compareAndSet(obj, prev, next));
311	return prev;
312	}
313
314	/**
315	* Atomically updates the field of the given object managed by this
316	* updater with the results of applying the given function to the
317	* current and given values, returning the updated value. The
318	* function should be side-effect-free, since it may be re-applied
319	* when attempted updates fail due to contention among threads. The
320	* function is applied with the current value as its first argument,
321	* and the given update as the second argument.
322	*
323	* @param obj An object whose field to get and set
324	* @param x the update value
325	* @param accumulatorFunction a side-effect-free function of two arguments
326	* @return the updated value
327	* @since 1.8
328	*/
329	public final long accumulateAndGet(T obj, long x,
330	LongBinaryOperator accumulatorFunction) {
331	long prev, next;
332	do {
333	prev = get(obj);
334	next = accumulatorFunction.applyAsLong(prev, x);
335	} while (!compareAndSet(obj, prev, next));
336	return next;
337	}
338
339	private static final class CASUpdater<T> extends AtomicLongFieldUpdater<T> {
340	private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
341	private final long offset;
342	/**
343	* if field is protected, the subclass constructing updater, else
344	* the same as tclass
345	*/
346	private final Class<?> cclass;
347	/** class holding the field */
348	private final Class<T> tclass;
349
350	CASUpdater(final Class<T> tclass, final String fieldName,
351	final Class<?> caller) {
352	final Field field;
353	final int modifiers;
354	try {
355	field = AccessController.doPrivileged(
356	new PrivilegedExceptionAction<Field>() {
357	public Field run() throws NoSuchFieldException {
358	return tclass.getDeclaredField(fieldName);
359	}
360	});
361	modifiers = field.getModifiers();
362	sun.reflect.misc.ReflectUtil.ensureMemberAccess(
363	caller, tclass, null, modifiers);
364	ClassLoader cl = tclass.getClassLoader();
365	ClassLoader ccl = caller.getClassLoader();
366	if ((ccl != null) && (ccl != cl) &&
367	((cl == null) \|\| !isAncestor(cl, ccl))) {
368	sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
369	}
370	} catch (PrivilegedActionException pae) {
371	throw new RuntimeException(pae.getException());
372	} catch (Exception ex) {
373	throw new RuntimeException(ex);
374	}
375
376	if (field.getType() != long.class)
377	throw new IllegalArgumentException("Must be long type");
378
379	if (!Modifier.isVolatile(modifiers))
380	throw new IllegalArgumentException("Must be volatile type");
381
382	this.cclass = (Modifier.isProtected(modifiers)) ? caller : tclass;
383	this.tclass = tclass;
384	this.offset = U.objectFieldOffset(field);
385	}
386
387	/**
388	* Checks that target argument is instance of cclass. On
389	* failure, throws cause.
390	*/
391	private final void accessCheck(T obj) {
392	if (!cclass.isInstance(obj))
393	throwAccessCheckException(obj);
394	}
395
396	/**
397	* Throws access exception if accessCheck failed due to
398	* protected access, else ClassCastException.
399	*/
400	private final void throwAccessCheckException(T obj) {
401	if (cclass == tclass)
402	throw new ClassCastException();
403	else
404	throw new RuntimeException(
405	new IllegalAccessException(
406	"Class " +
407	cclass.getName() +
408	" can not access a protected member of class " +
409	tclass.getName() +
410	" using an instance of " +
411	obj.getClass().getName()));
412	}
413
414	public final boolean compareAndSet(T obj, long expect, long update) {
415	accessCheck(obj);
416	return U.compareAndSwapLong(obj, offset, expect, update);
417	}
418
419	public final boolean weakCompareAndSet(T obj, long expect, long update) {
420	accessCheck(obj);
421	return U.compareAndSwapLong(obj, offset, expect, update);
422	}
423
424	public final void set(T obj, long newValue) {
425	accessCheck(obj);
426	U.putLongVolatile(obj, offset, newValue);
427	}
428
429	public final void lazySet(T obj, long newValue) {
430	accessCheck(obj);
431	U.putOrderedLong(obj, offset, newValue);
432	}
433
434	public final long get(T obj) {
435	accessCheck(obj);
436	return U.getLongVolatile(obj, offset);
437	}
438
439	public final long getAndSet(T obj, long newValue) {
440	accessCheck(obj);
441	return U.getAndSetLong(obj, offset, newValue);
442	}
443
444	public final long getAndAdd(T obj, long delta) {
445	accessCheck(obj);
446	return U.getAndAddLong(obj, offset, delta);
447	}
448
449	public final long getAndIncrement(T obj) {
450	return getAndAdd(obj, 1);
451	}
452
453	public final long getAndDecrement(T obj) {
454	return getAndAdd(obj, -1);
455	}
456
457	public final long incrementAndGet(T obj) {
458	return getAndAdd(obj, 1) + 1;
459	}
460
461	public final long decrementAndGet(T obj) {
462	return getAndAdd(obj, -1) - 1;
463	}
464
465	public final long addAndGet(T obj, long delta) {
466	return getAndAdd(obj, delta) + delta;
467	}
468	}
469
470	private static final class LockedUpdater<T> extends AtomicLongFieldUpdater<T> {
471	private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
472	private final long offset;
473	/**
474	* if field is protected, the subclass constructing updater, else
475	* the same as tclass
476	*/
477	private final Class<?> cclass;
478	/** class holding the field */
479	private final Class<T> tclass;
480
481	LockedUpdater(final Class<T> tclass, final String fieldName,
482	final Class<?> caller) {
483	Field field = null;
484	int modifiers = 0;
485	try {
486	field = AccessController.doPrivileged(
487	new PrivilegedExceptionAction<Field>() {
488	public Field run() throws NoSuchFieldException {
489	return tclass.getDeclaredField(fieldName);
490	}
491	});
492	modifiers = field.getModifiers();
493	sun.reflect.misc.ReflectUtil.ensureMemberAccess(
494	caller, tclass, null, modifiers);
495	ClassLoader cl = tclass.getClassLoader();
496	ClassLoader ccl = caller.getClassLoader();
497	if ((ccl != null) && (ccl != cl) &&
498	((cl == null) \|\| !isAncestor(cl, ccl))) {
499	sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
500	}
501	} catch (PrivilegedActionException pae) {
502	throw new RuntimeException(pae.getException());
503	} catch (Exception ex) {
504	throw new RuntimeException(ex);
505	}
506
507	if (field.getType() != long.class)
508	throw new IllegalArgumentException("Must be long type");
509
510	if (!Modifier.isVolatile(modifiers))
511	throw new IllegalArgumentException("Must be volatile type");
512
513	this.cclass = (Modifier.isProtected(modifiers)) ? caller : tclass;
514	this.tclass = tclass;
515	this.offset = U.objectFieldOffset(field);
516	}
517
518	/**
519	* Checks that target argument is instance of cclass. On
520	* failure, throws cause.
521	*/
522	private final void accessCheck(T obj) {
523	if (!cclass.isInstance(obj))
524	throw accessCheckException(obj);
525	}
526
527	/**
528	* Returns access exception if accessCheck failed due to
529	* protected access, else ClassCastException.
530	*/
531	private final RuntimeException accessCheckException(T obj) {
532	if (cclass == tclass)
533	return new ClassCastException();
534	else
535	return new RuntimeException(
536	new IllegalAccessException(
537	"Class " +
538	cclass.getName() +
539	" can not access a protected member of class " +
540	tclass.getName() +
541	" using an instance of " +
542	obj.getClass().getName()));
543	}
544
545	public final boolean compareAndSet(T obj, long expect, long update) {
546	accessCheck(obj);
547	synchronized (this) {
548	long v = U.getLong(obj, offset);
549	if (v != expect)
550	return false;
551	U.putLong(obj, offset, update);
552	return true;
553	}
554	}
555
556	public final boolean weakCompareAndSet(T obj, long expect, long update) {
557	return compareAndSet(obj, expect, update);
558	}
559
560	public final void set(T obj, long newValue) {
561	accessCheck(obj);
562	synchronized (this) {
563	U.putLong(obj, offset, newValue);
564	}
565	}
566
567	public final void lazySet(T obj, long newValue) {
568	set(obj, newValue);
569	}
570
571	public final long get(T obj) {
572	accessCheck(obj);
573	synchronized (this) {
574	return U.getLong(obj, offset);
575	}
576	}
577	}
578
579	/**
580	* Returns true if the second classloader can be found in the first
581	* classloader's delegation chain.
582	* Equivalent to the inaccessible: first.isAncestor(second).
583	*/
584	static boolean isAncestor(ClassLoader first, ClassLoader second) {
585	ClassLoader acl = first;
586	do {
587	acl = acl.getParent();
588	if (second == acl) {
589	return true;
590	}
591	} while (acl != null);
592	return false;
593	}
594	}