jdk-sandbox: jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReference.java@9548f8d846e9 (annotated)

2 90ce3da70b43 Initial load duke parents: diff changeset	1	/*
90ce3da70b43 Initial load duke parents: diff changeset	2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load duke parents: diff changeset	3	*
90ce3da70b43 Initial load duke parents: diff changeset	4	* This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load duke parents: diff changeset	5	* under the terms of the GNU General Public License version 2 only, as
5506 202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 2 diff changeset	6	* published by the Free Software Foundation. Oracle designates this
2 90ce3da70b43 Initial load duke parents: diff changeset	7	* particular file as subject to the "Classpath" exception as provided
5506 202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 2 diff changeset	8	* by Oracle in the LICENSE file that accompanied this code.
2 90ce3da70b43 Initial load duke parents: diff changeset	9	*
90ce3da70b43 Initial load duke parents: diff changeset	10	* This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load duke parents: diff changeset	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load duke parents: diff changeset	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
90ce3da70b43 Initial load duke parents: diff changeset	13	* version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load duke parents: diff changeset	14	* accompanied this code).
90ce3da70b43 Initial load duke parents: diff changeset	15	*
90ce3da70b43 Initial load duke parents: diff changeset	16	* You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load duke parents: diff changeset	17	* 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load duke parents: diff changeset	18	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load duke parents: diff changeset	19	*
5506 202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 2 diff changeset	20	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 2 diff changeset	21	* or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 2 diff changeset	22	* questions.
2 90ce3da70b43 Initial load duke parents: diff changeset	23	*/
90ce3da70b43 Initial load duke parents: diff changeset	24
90ce3da70b43 Initial load duke parents: diff changeset	25	/*
90ce3da70b43 Initial load duke parents: diff changeset	26	* This file is available under and governed by the GNU General Public
90ce3da70b43 Initial load duke parents: diff changeset	27	* License version 2 only, as published by the Free Software Foundation.
90ce3da70b43 Initial load duke parents: diff changeset	28	* However, the following notice accompanied the original version of this
90ce3da70b43 Initial load duke parents: diff changeset	29	* file:
90ce3da70b43 Initial load duke parents: diff changeset	30	*
90ce3da70b43 Initial load duke parents: diff changeset	31	* Written by Doug Lea with assistance from members of JCP JSR-166
90ce3da70b43 Initial load duke parents: diff changeset	32	* Expert Group and released to the public domain, as explained at
9242 ef138d47df58 7034657: Update Creative Commons license URL in legal notices dl parents: 5506 diff changeset	33	* http://creativecommons.org/publicdomain/zero/1.0/
2 90ce3da70b43 Initial load duke parents: diff changeset	34	*/
90ce3da70b43 Initial load duke parents: diff changeset	35
90ce3da70b43 Initial load duke parents: diff changeset	36	package java.util.concurrent.atomic;
32838 caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	37
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	38	import java.lang.invoke.MethodHandles;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	39	import java.lang.invoke.VarHandle;
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	40	import java.util.function.BinaryOperator;
32838 caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	41	import java.util.function.UnaryOperator;
2 90ce3da70b43 Initial load duke parents: diff changeset	42
90ce3da70b43 Initial load duke parents: diff changeset	43	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	44	* An object reference that may be updated atomically. See the {@link
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	45	* VarHandle} specification for descriptions of the properties of
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	46	* atomic accesses.
2 90ce3da70b43 Initial load duke parents: diff changeset	47	* @since 1.5
90ce3da70b43 Initial load duke parents: diff changeset	48	* @author Doug Lea
90ce3da70b43 Initial load duke parents: diff changeset	49	* @param <V> The type of object referred to by this reference
90ce3da70b43 Initial load duke parents: diff changeset	50	*/
14325 622c473a21aa 8001575: Minor/sync/cleanup j.u.c with Dougs CVS - Oct 2012 dl parents: 11134 diff changeset	51	public class AtomicReference<V> implements java.io.Serializable {
2 90ce3da70b43 Initial load duke parents: diff changeset	52	private static final long serialVersionUID = -1848883965231344442L;
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	53	private static final VarHandle VALUE;
2 90ce3da70b43 Initial load duke parents: diff changeset	54	static {
11134 9ff7640994bf 7117360: Warnings in java.util.concurrent.atomic package dl parents: 9242 diff changeset	55	try {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	56	MethodHandles.Lookup l = MethodHandles.lookup();
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	57	VALUE = l.findVarHandle(AtomicReference.class, "value", Object.class);
32838 caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	58	} catch (ReflectiveOperationException e) {
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	59	throw new Error(e);
caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	60	}
2 90ce3da70b43 Initial load duke parents: diff changeset	61	}
90ce3da70b43 Initial load duke parents: diff changeset	62
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	63	private volatile Object value;
2 90ce3da70b43 Initial load duke parents: diff changeset	64
90ce3da70b43 Initial load duke parents: diff changeset	65	/**
90ce3da70b43 Initial load duke parents: diff changeset	66	* Creates a new AtomicReference with the given initial value.
90ce3da70b43 Initial load duke parents: diff changeset	67	*
90ce3da70b43 Initial load duke parents: diff changeset	68	* @param initialValue the initial value
90ce3da70b43 Initial load duke parents: diff changeset	69	*/
90ce3da70b43 Initial load duke parents: diff changeset	70	public AtomicReference(V initialValue) {
90ce3da70b43 Initial load duke parents: diff changeset	71	value = initialValue;
90ce3da70b43 Initial load duke parents: diff changeset	72	}
90ce3da70b43 Initial load duke parents: diff changeset	73
90ce3da70b43 Initial load duke parents: diff changeset	74	/**
90ce3da70b43 Initial load duke parents: diff changeset	75	* Creates a new AtomicReference with null initial value.
90ce3da70b43 Initial load duke parents: diff changeset	76	*/
90ce3da70b43 Initial load duke parents: diff changeset	77	public AtomicReference() {
90ce3da70b43 Initial load duke parents: diff changeset	78	}
90ce3da70b43 Initial load duke parents: diff changeset	79
90ce3da70b43 Initial load duke parents: diff changeset	80	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	81	* Returns the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	82	* with memory effects as specified by {@link VarHandle#getVolatile}.
2 90ce3da70b43 Initial load duke parents: diff changeset	83	*
90ce3da70b43 Initial load duke parents: diff changeset	84	* @return the current value
90ce3da70b43 Initial load duke parents: diff changeset	85	*/
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	86	@SuppressWarnings("unchecked")
2 90ce3da70b43 Initial load duke parents: diff changeset	87	public final V get() {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	88	return (V)value;
2 90ce3da70b43 Initial load duke parents: diff changeset	89	}
90ce3da70b43 Initial load duke parents: diff changeset	90
90ce3da70b43 Initial load duke parents: diff changeset	91	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	92	* Sets the value to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	93	* with memory effects as specified by {@link VarHandle#setVolatile}.
2 90ce3da70b43 Initial load duke parents: diff changeset	94	*
90ce3da70b43 Initial load duke parents: diff changeset	95	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	96	*/
90ce3da70b43 Initial load duke parents: diff changeset	97	public final void set(V newValue) {
90ce3da70b43 Initial load duke parents: diff changeset	98	value = newValue;
90ce3da70b43 Initial load duke parents: diff changeset	99	}
90ce3da70b43 Initial load duke parents: diff changeset	100
90ce3da70b43 Initial load duke parents: diff changeset	101	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	102	* Sets the value to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	103	* with memory effects as specified by {@link VarHandle#setRelease}.
2 90ce3da70b43 Initial load duke parents: diff changeset	104	*
90ce3da70b43 Initial load duke parents: diff changeset	105	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	106	* @since 1.6
90ce3da70b43 Initial load duke parents: diff changeset	107	*/
90ce3da70b43 Initial load duke parents: diff changeset	108	public final void lazySet(V newValue) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	109	VALUE.setRelease(this, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	110	}
90ce3da70b43 Initial load duke parents: diff changeset	111
90ce3da70b43 Initial load duke parents: diff changeset	112	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	113	* Atomically sets the value to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	114	* if the current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	115	* with memory effects as specified by {@link VarHandle#compareAndSet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	116	*
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	117	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	118	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	119	* @return {@code true} if successful. False return indicates that
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	120	* the actual value was not equal to the expected value.
2 90ce3da70b43 Initial load duke parents: diff changeset	121	*/
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	122	public final boolean compareAndSet(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	123	return VALUE.compareAndSet(this, expectedValue, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	124	}
90ce3da70b43 Initial load duke parents: diff changeset	125
90ce3da70b43 Initial load duke parents: diff changeset	126	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	127	* Possibly atomically sets the value to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	128	* if the current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	129	* with memory effects as specified by {@link VarHandle#weakCompareAndSet}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	130	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	131	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	132	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	133	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	134	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	135	public final boolean weakCompareAndSet(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	136	return VALUE.weakCompareAndSet(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	137	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	138
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	139	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	140	* Atomically sets the value to {@code newValue} and returns the old value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	141	* with memory effects as specified by {@link VarHandle#getAndSet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	142	*
90ce3da70b43 Initial load duke parents: diff changeset	143	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	144	* @return the previous value
90ce3da70b43 Initial load duke parents: diff changeset	145	*/
15020 50394fa17c1b 8006007: j.u.c.atomic classes should use intrinsic getAndXXX provided by 7023898 chegar parents: 14325 diff changeset	146	@SuppressWarnings("unchecked")
2 90ce3da70b43 Initial load duke parents: diff changeset	147	public final V getAndSet(V newValue) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	148	return (V)VALUE.getAndSet(this, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	149	}
90ce3da70b43 Initial load duke parents: diff changeset	150
90ce3da70b43 Initial load duke parents: diff changeset	151	/**
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	152	* Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	153	* applying the given function, returning the previous value. The
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	154	* function should be side-effect-free, since it may be re-applied
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	155	* when attempted updates fail due to contention among threads.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	156	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	157	* @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	158	* @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	159	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	160	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	161	public final V getAndUpdate(UnaryOperator<V> updateFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	162	V prev = get(), next = null;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	163	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	164	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	165	next = updateFunction.apply(prev);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	166	if (weakCompareAndSetVolatile(prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	167	return prev;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	168	haveNext = (prev == (prev = get()));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	169	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	170	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	171
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	172	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	173	* Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	174	* applying the given function, returning the updated value. The
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	175	* function should be side-effect-free, since it may be re-applied
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	176	* when attempted updates fail due to contention among threads.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	177	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	178	* @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	179	* @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	180	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	181	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	182	public final V updateAndGet(UnaryOperator<V> updateFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	183	V prev = get(), next = null;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	184	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	185	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	186	next = updateFunction.apply(prev);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	187	if (weakCompareAndSetVolatile(prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	188	return next;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	189	haveNext = (prev == (prev = get()));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	190	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	191	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	192
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	193	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	194	* Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	195	* applying the given function to the current and given values,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	196	* returning the previous value. The function should be
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	197	* side-effect-free, since it may be re-applied when attempted
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	198	* updates fail due to contention among threads. The function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	199	* is applied with the current value as its first argument,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	200	* and the given update as the second argument.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	201	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	202	* @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	203	* @param accumulatorFunction a side-effect-free function of two arguments
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	204	* @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	205	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	206	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	207	public final V getAndAccumulate(V x,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	208	BinaryOperator<V> accumulatorFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	209	V prev = get(), next = null;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	210	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	211	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	212	next = accumulatorFunction.apply(prev, x);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	213	if (weakCompareAndSetVolatile(prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	214	return prev;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	215	haveNext = (prev == (prev = get()));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	216	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	217	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	218
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	219	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	220	* Atomically updates the current value with the results of
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	221	* applying the given function to the current and given values,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	222	* returning the updated value. The function should be
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	223	* side-effect-free, since it may be re-applied when attempted
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	224	* updates fail due to contention among threads. The function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	225	* is applied with the current value as its first argument,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	226	* and the given update as the second argument.
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	227	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	228	* @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	229	* @param accumulatorFunction a side-effect-free function of two arguments
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	230	* @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	231	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	232	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	233	public final V accumulateAndGet(V x,
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	234	BinaryOperator<V> accumulatorFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	235	V prev = get(), next = null;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	236	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	237	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	238	next = accumulatorFunction.apply(prev, x);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	239	if (weakCompareAndSetVolatile(prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	240	return next;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	241	haveNext = (prev == (prev = get()));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	242	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	243	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	244
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	245	/**
2 90ce3da70b43 Initial load duke parents: diff changeset	246	* Returns the String representation of the current value.
15020 50394fa17c1b 8006007: j.u.c.atomic classes should use intrinsic getAndXXX provided by 7023898 chegar parents: 14325 diff changeset	247	* @return the String representation of the current value
2 90ce3da70b43 Initial load duke parents: diff changeset	248	*/
90ce3da70b43 Initial load duke parents: diff changeset	249	public String toString() {
90ce3da70b43 Initial load duke parents: diff changeset	250	return String.valueOf(get());
90ce3da70b43 Initial load duke parents: diff changeset	251	}
90ce3da70b43 Initial load duke parents: diff changeset	252
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	253	// jdk9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	254
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	255	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	256	* Returns the current value, with memory semantics of reading as
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	257	* if the variable was declared non-{@code volatile}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	258	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	259	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	260	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	261	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	262	public final V getPlain() {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	263	return (V)VALUE.get(this);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	264	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	265
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	266	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	267	* Sets the value to {@code newValue}, with memory semantics
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	268	* of setting as if the variable was declared non-{@code volatile}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	269	* and non-{@code final}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	270	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	271	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	272	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	273	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	274	public final void setPlain(V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	275	VALUE.set(this, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	276	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	277
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	278	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	279	* Returns the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	280	* with memory effects as specified by {@link VarHandle#getOpaque}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	281	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	282	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	283	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	284	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	285	public final V getOpaque() {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	286	return (V)VALUE.getOpaque(this);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	287	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	288
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	289	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	290	* Sets the value to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	291	* with memory effects as specified by {@link VarHandle#setOpaque}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	292	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	293	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	294	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	295	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	296	public final void setOpaque(V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	297	VALUE.setOpaque(this, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	298	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	299
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	300	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	301	* Returns the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	302	* with memory effects as specified by {@link VarHandle#getAcquire}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	303	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	304	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	305	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	306	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	307	public final V getAcquire() {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	308	return (V)VALUE.getAcquire(this);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	309	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	310
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	311	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	312	* Sets the value to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	313	* with memory effects as specified by {@link VarHandle#setRelease}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	314	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	315	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	316	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	317	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	318	public final void setRelease(V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	319	VALUE.setRelease(this, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	320	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	321
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	322	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	323	* Atomically sets the value to {@code newValue} if the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	324	* referred to as the <em>witness value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	325	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	326	* {@link VarHandle#compareAndExchange}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	327	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	328	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	329	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	330	* @return the witness value, which will be the same as the
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	331	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	332	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	333	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	334	public final V compareAndExchange(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	335	return (V)VALUE.compareAndExchange(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	336	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	337
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	338	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	339	* Atomically sets the value to {@code newValue} if the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	340	* referred to as the <em>witness value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	341	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	342	* {@link VarHandle#compareAndExchangeAcquire}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	343	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	344	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	345	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	346	* @return the witness value, which will be the same as the
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	347	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	348	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	349	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	350	public final V compareAndExchangeAcquire(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	351	return (V)VALUE.compareAndExchangeAcquire(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	352	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	353
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	354	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	355	* Atomically sets the value to {@code newValue} if the current value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	356	* referred to as the <em>witness value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	357	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	358	* {@link VarHandle#compareAndExchangeRelease}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	359	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	360	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	361	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	362	* @return the witness value, which will be the same as the
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	363	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	364	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	365	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	366	public final V compareAndExchangeRelease(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	367	return (V)VALUE.compareAndExchangeRelease(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	368	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	369
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	370	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	371	* Possibly atomically sets the value to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	372	* if the current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	373	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	374	* {@link VarHandle#weakCompareAndSetVolatile}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	375	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	376	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	377	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	378	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	379	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	380	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	381	public final boolean weakCompareAndSetVolatile(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	382	return VALUE.weakCompareAndSetVolatile(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	383	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	384
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	385	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	386	* Possibly atomically sets the value to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	387	* if the current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	388	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	389	* {@link VarHandle#weakCompareAndSetAcquire}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	390	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	391	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	392	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	393	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	394	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	395	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	396	public final boolean weakCompareAndSetAcquire(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	397	return VALUE.weakCompareAndSetAcquire(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	398	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	399
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	400	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	401	* Possibly atomically sets the value to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	402	* if the current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	403	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	404	* {@link VarHandle#weakCompareAndSetRelease}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	405	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	406	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	407	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	408	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	409	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	410	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	411	public final boolean weakCompareAndSetRelease(V expectedValue, V newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	412	return VALUE.weakCompareAndSetRelease(this, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	413	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	414
2 90ce3da70b43 Initial load duke parents: diff changeset	415	}

author	dl
	Fri, 15 Jul 2016 14:04:09 -0700
changeset 39725	9548f8d846e9
parent 36936	bfcdf736a998
child 39781	8190c004acbd
permissions	-rw-r--r--