jdk-sandbox: jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongArray.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: 5169 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: 5169 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: 5169 diff changeset	20	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 5169 diff changeset	21	* or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices ohair parents: 5169 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: 7976 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.LongBinaryOperator;
32838 caeef2c79243 8134854: Bulk integration of java.util.concurrent.atomic classes dl parents: 25859 diff changeset	41	import java.util.function.LongUnaryOperator;
2 90ce3da70b43 Initial load duke parents: diff changeset	42
90ce3da70b43 Initial load duke parents: diff changeset	43	/**
90ce3da70b43 Initial load duke parents: diff changeset	44	* A {@code long} array in which elements may be updated atomically.
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	45	* See the {@link VarHandle} specification for descriptions of the
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	46	* properties of 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	*/
90ce3da70b43 Initial load duke parents: diff changeset	50	public class AtomicLongArray implements java.io.Serializable {
90ce3da70b43 Initial load duke parents: diff changeset	51	private static final long serialVersionUID = -2308431214976778248L;
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	52	private static final VarHandle AA
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	53	= MethodHandles.arrayElementVarHandle(long[].class);
2 90ce3da70b43 Initial load duke parents: diff changeset	54	private final long[] array;
90ce3da70b43 Initial load duke parents: diff changeset	55
90ce3da70b43 Initial load duke parents: diff changeset	56	/**
7976 f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	57	* Creates a new AtomicLongArray of the given length, with all
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	58	* elements initially zero.
2 90ce3da70b43 Initial load duke parents: diff changeset	59	*
90ce3da70b43 Initial load duke parents: diff changeset	60	* @param length the length of the array
90ce3da70b43 Initial load duke parents: diff changeset	61	*/
90ce3da70b43 Initial load duke parents: diff changeset	62	public AtomicLongArray(int length) {
90ce3da70b43 Initial load duke parents: diff changeset	63	array = new long[length];
90ce3da70b43 Initial load duke parents: diff changeset	64	}
90ce3da70b43 Initial load duke parents: diff changeset	65
90ce3da70b43 Initial load duke parents: diff changeset	66	/**
90ce3da70b43 Initial load duke parents: diff changeset	67	* Creates a new AtomicLongArray with the same length as, and
90ce3da70b43 Initial load duke parents: diff changeset	68	* all elements copied from, the given array.
90ce3da70b43 Initial load duke parents: diff changeset	69	*
90ce3da70b43 Initial load duke parents: diff changeset	70	* @param array the array to copy elements from
90ce3da70b43 Initial load duke parents: diff changeset	71	* @throws NullPointerException if array is null
90ce3da70b43 Initial load duke parents: diff changeset	72	*/
90ce3da70b43 Initial load duke parents: diff changeset	73	public AtomicLongArray(long[] array) {
7976 f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	74	// Visibility guaranteed by final field guarantees
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	75	this.array = array.clone();
2 90ce3da70b43 Initial load duke parents: diff changeset	76	}
90ce3da70b43 Initial load duke parents: diff changeset	77
90ce3da70b43 Initial load duke parents: diff changeset	78	/**
90ce3da70b43 Initial load duke parents: diff changeset	79	* Returns the length of the array.
90ce3da70b43 Initial load duke parents: diff changeset	80	*
90ce3da70b43 Initial load duke parents: diff changeset	81	* @return the length of the array
90ce3da70b43 Initial load duke parents: diff changeset	82	*/
90ce3da70b43 Initial load duke parents: diff changeset	83	public final int length() {
90ce3da70b43 Initial load duke parents: diff changeset	84	return array.length;
90ce3da70b43 Initial load duke parents: diff changeset	85	}
90ce3da70b43 Initial load duke parents: diff changeset	86
90ce3da70b43 Initial load duke parents: diff changeset	87	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	88	* Returns the current value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	89	* with memory effects as specified by {@link VarHandle#getVolatile}.
2 90ce3da70b43 Initial load duke parents: diff changeset	90	*
90ce3da70b43 Initial load duke parents: diff changeset	91	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	92	* @return the current value
90ce3da70b43 Initial load duke parents: diff changeset	93	*/
90ce3da70b43 Initial load duke parents: diff changeset	94	public final long get(int i) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	95	return (long)AA.getVolatile(array, i);
2 90ce3da70b43 Initial load duke parents: diff changeset	96	}
90ce3da70b43 Initial load duke parents: diff changeset	97
90ce3da70b43 Initial load duke parents: diff changeset	98	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	99	* Sets the element at index {@code i} to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	100	* with memory effects as specified by {@link VarHandle#setVolatile}.
2 90ce3da70b43 Initial load duke parents: diff changeset	101	*
90ce3da70b43 Initial load duke parents: diff changeset	102	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	103	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	104	*/
90ce3da70b43 Initial load duke parents: diff changeset	105	public final void set(int i, long newValue) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	106	AA.setVolatile(array, i, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	107	}
90ce3da70b43 Initial load duke parents: diff changeset	108
90ce3da70b43 Initial load duke parents: diff changeset	109	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	110	* Sets the element at index {@code i} to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	111	* with memory effects as specified by {@link VarHandle#setRelease}.
2 90ce3da70b43 Initial load duke parents: diff changeset	112	*
90ce3da70b43 Initial load duke parents: diff changeset	113	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	114	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	115	* @since 1.6
90ce3da70b43 Initial load duke parents: diff changeset	116	*/
90ce3da70b43 Initial load duke parents: diff changeset	117	public final void lazySet(int i, long newValue) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	118	AA.setRelease(array, i, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	119	}
90ce3da70b43 Initial load duke parents: diff changeset	120
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	* Atomically sets the element at index {@code i} to {@code
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	123	* newValue} and returns the old value,
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	124	* with memory effects as specified by {@link VarHandle#getAndSet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	125	*
90ce3da70b43 Initial load duke parents: diff changeset	126	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	127	* @param newValue the new value
90ce3da70b43 Initial load duke parents: diff changeset	128	* @return the previous value
90ce3da70b43 Initial load duke parents: diff changeset	129	*/
90ce3da70b43 Initial load duke parents: diff changeset	130	public final long getAndSet(int i, long newValue) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	131	return (long)AA.getAndSet(array, i, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	132	}
90ce3da70b43 Initial load duke parents: diff changeset	133
90ce3da70b43 Initial load duke parents: diff changeset	134	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	135	* Atomically sets the element at index {@code i} to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	136	* if the element's current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	137	* with memory effects as specified by {@link VarHandle#compareAndSet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	138	*
90ce3da70b43 Initial load duke parents: diff changeset	139	* @param i the index
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	140	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	141	* @param newValue the new value
18576 7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl dl parents: 16011 diff changeset	142	* @return {@code true} if successful. False return indicates that
2 90ce3da70b43 Initial load duke parents: diff changeset	143	* the actual value was not equal to the expected value.
90ce3da70b43 Initial load duke parents: diff changeset	144	*/
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	145	public final boolean compareAndSet(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	146	return AA.compareAndSet(array, i, expectedValue, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	147	}
90ce3da70b43 Initial load duke parents: diff changeset	148
90ce3da70b43 Initial load duke parents: diff changeset	149	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	150	* Possibly atomically sets the element at index {@code i} to
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	151	* {@code newValue} if the element's current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	152	* with memory effects as specified by {@link VarHandle#weakCompareAndSet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	153	*
90ce3da70b43 Initial load duke parents: diff changeset	154	* @param i the index
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	155	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	156	* @param newValue the new value
18576 7a5c231327af 8019377: Sync j.u.c locks and atomic from 166 to tl dl parents: 16011 diff changeset	157	* @return {@code true} if successful
2 90ce3da70b43 Initial load duke parents: diff changeset	158	*/
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	159	public final boolean weakCompareAndSet(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	160	return AA.weakCompareAndSet(array, i, expectedValue, newValue);
2 90ce3da70b43 Initial load duke parents: diff changeset	161	}
90ce3da70b43 Initial load duke parents: diff changeset	162
90ce3da70b43 Initial load duke parents: diff changeset	163	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	164	* Atomically increments the value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	165	* with memory effects as specified by {@link VarHandle#getAndAdd}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	166	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	167	* <p>Equivalent to {@code getAndAdd(i, 1)}.
2 90ce3da70b43 Initial load duke parents: diff changeset	168	*
90ce3da70b43 Initial load duke parents: diff changeset	169	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	170	* @return the previous value
90ce3da70b43 Initial load duke parents: diff changeset	171	*/
90ce3da70b43 Initial load duke parents: diff changeset	172	public final long getAndIncrement(int i) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	173	return (long)AA.getAndAdd(array, i, 1L);
2 90ce3da70b43 Initial load duke parents: diff changeset	174	}
90ce3da70b43 Initial load duke parents: diff changeset	175
90ce3da70b43 Initial load duke parents: diff changeset	176	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	177	* Atomically decrements the value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	178	* with memory effects as specified by {@link VarHandle#getAndAdd}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	179	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	180	* <p>Equivalent to {@code getAndAdd(i, -1)}.
2 90ce3da70b43 Initial load duke parents: diff changeset	181	*
90ce3da70b43 Initial load duke parents: diff changeset	182	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	183	* @return the previous value
90ce3da70b43 Initial load duke parents: diff changeset	184	*/
90ce3da70b43 Initial load duke parents: diff changeset	185	public final long getAndDecrement(int i) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	186	return (long)AA.getAndAdd(array, i, -1L);
2 90ce3da70b43 Initial load duke parents: diff changeset	187	}
90ce3da70b43 Initial load duke parents: diff changeset	188
90ce3da70b43 Initial load duke parents: diff changeset	189	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	190	* Atomically adds the given value to the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	191	* with memory effects as specified by {@link VarHandle#getAndAdd}.
2 90ce3da70b43 Initial load duke parents: diff changeset	192	*
90ce3da70b43 Initial load duke parents: diff changeset	193	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	194	* @param delta the value to add
90ce3da70b43 Initial load duke parents: diff changeset	195	* @return the previous value
90ce3da70b43 Initial load duke parents: diff changeset	196	*/
90ce3da70b43 Initial load duke parents: diff changeset	197	public final long getAndAdd(int i, long delta) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	198	return (long)AA.getAndAdd(array, i, delta);
2 90ce3da70b43 Initial load duke parents: diff changeset	199	}
90ce3da70b43 Initial load duke parents: diff changeset	200
90ce3da70b43 Initial load duke parents: diff changeset	201	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	202	* Atomically increments the value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	203	* with memory effects as specified by {@link VarHandle#addAndGet}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	204	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	205	* <p>Equivalent to {@code addAndGet(i, 1)}.
2 90ce3da70b43 Initial load duke parents: diff changeset	206	*
90ce3da70b43 Initial load duke parents: diff changeset	207	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	208	* @return the updated value
90ce3da70b43 Initial load duke parents: diff changeset	209	*/
90ce3da70b43 Initial load duke parents: diff changeset	210	public final long incrementAndGet(int i) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	211	return (long)AA.addAndGet(array, i, 1L);
2 90ce3da70b43 Initial load duke parents: diff changeset	212	}
90ce3da70b43 Initial load duke parents: diff changeset	213
90ce3da70b43 Initial load duke parents: diff changeset	214	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	215	* Atomically decrements the value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	216	* with memory effects as specified by {@link VarHandle#addAndGet}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	217	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	218	* <p>Equivalent to {@code addAndGet(i, -1)}.
2 90ce3da70b43 Initial load duke parents: diff changeset	219	*
90ce3da70b43 Initial load duke parents: diff changeset	220	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	221	* @return the updated value
90ce3da70b43 Initial load duke parents: diff changeset	222	*/
90ce3da70b43 Initial load duke parents: diff changeset	223	public final long decrementAndGet(int i) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	224	return (long)AA.addAndGet(array, i, -1L);
2 90ce3da70b43 Initial load duke parents: diff changeset	225	}
90ce3da70b43 Initial load duke parents: diff changeset	226
90ce3da70b43 Initial load duke parents: diff changeset	227	/**
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	228	* Atomically adds the given value to the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	229	* with memory effects as specified by {@link VarHandle#addAndGet}.
2 90ce3da70b43 Initial load duke parents: diff changeset	230	*
90ce3da70b43 Initial load duke parents: diff changeset	231	* @param i the index
90ce3da70b43 Initial load duke parents: diff changeset	232	* @param delta the value to add
90ce3da70b43 Initial load duke parents: diff changeset	233	* @return the updated value
90ce3da70b43 Initial load duke parents: diff changeset	234	*/
90ce3da70b43 Initial load duke parents: diff changeset	235	public long addAndGet(int i, long delta) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	236	return (long)AA.addAndGet(array, i, delta);
2 90ce3da70b43 Initial load duke parents: diff changeset	237	}
90ce3da70b43 Initial load duke parents: diff changeset	238
90ce3da70b43 Initial load duke parents: diff changeset	239	/**
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	240	* Atomically updates the element at index {@code i} with the results
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	241	* of 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	242	* 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	243	* 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	244	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	245	* @param i the index
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	246	* @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	247	* @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	248	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	249	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	250	public final long getAndUpdate(int i, LongUnaryOperator updateFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	251	long prev = get(i), next = 0L;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	252	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	253	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	254	next = updateFunction.applyAsLong(prev);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	255	if (weakCompareAndSetVolatile(i, prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	256	return prev;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	257	haveNext = (prev == (prev = get(i)));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	258	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	259	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	260
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	261	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	262	* Atomically updates the element at index {@code i} with the results
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	263	* of 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	264	* 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	265	* 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	266	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	267	* @param i the index
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	268	* @param updateFunction a side-effect-free function
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	269	* @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	270	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	271	*/
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	272	public final long updateAndGet(int i, LongUnaryOperator updateFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	273	long prev = get(i), next = 0L;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	274	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	275	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	276	next = updateFunction.applyAsLong(prev);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	277	if (weakCompareAndSetVolatile(i, prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	278	return next;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	279	haveNext = (prev == (prev = get(i)));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	280	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	281	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	282
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	283	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	284	* Atomically updates the element at index {@code i} with the
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	285	* results of applying the given function to the current and given
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	286	* values, returning the previous value. The function should be
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	287	* side-effect-free, since it may be re-applied when attempted
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	288	* updates fail due to contention among threads. The function is
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	289	* applied with the current value of the element at index {@code i}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	290	* as its first argument, and the given update as the second
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	291	* argument.
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	292	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	293	* @param i the index
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	294	* @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	295	* @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	296	* @return the previous value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	297	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	298	*/
19794 c5a8e71fbdb6 8024103: AtomicLongArray getAndAccumulate/accumulateAndGet have int type for new value arg chegar parents: 18576 diff changeset	299	public final long getAndAccumulate(int i, long x,
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	300	LongBinaryOperator accumulatorFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	301	long prev = get(i), next = 0L;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	302	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	303	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	304	next = accumulatorFunction.applyAsLong(prev, x);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	305	if (weakCompareAndSetVolatile(i, prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	306	return prev;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	307	haveNext = (prev == (prev = get(i)));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	308	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	309	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	310
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	311	/**
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	312	* Atomically updates the element at index {@code i} with the
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	313	* results of applying the given function to the current and given
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	314	* values, returning the updated value. The function should be
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	315	* side-effect-free, since it may be re-applied when attempted
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	316	* updates fail due to contention among threads. The function is
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	317	* applied with the current value of the element at index {@code i}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	318	* as its first argument, and the given update as the second
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	319	* argument.
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	320	*
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	321	* @param i the index
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	322	* @param x the update value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	323	* @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	324	* @return the updated value
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	325	* @since 1.8
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	326	*/
19794 c5a8e71fbdb6 8024103: AtomicLongArray getAndAccumulate/accumulateAndGet have int type for new value arg chegar parents: 18576 diff changeset	327	public final long accumulateAndGet(int i, long x,
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	328	LongBinaryOperator accumulatorFunction) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	329	long prev = get(i), next = 0L;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	330	for (boolean haveNext = false;;) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	331	if (!haveNext)
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	332	next = accumulatorFunction.applyAsLong(prev, x);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	333	if (weakCompareAndSetVolatile(i, prev, next))
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	334	return next;
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	335	haveNext = (prev == (prev = get(i)));
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	336	}
15267 c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	337	}
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	338
c884f548a25f 8001666: Add lambda-compatible atomics and accumulators to the ActomicXXX classes dl parents: 15020 diff changeset	339	/**
2 90ce3da70b43 Initial load duke parents: diff changeset	340	* Returns the String representation of the current values of array.
7976 f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	341	* @return the String representation of the current values of array
2 90ce3da70b43 Initial load duke parents: diff changeset	342	*/
90ce3da70b43 Initial load duke parents: diff changeset	343	public String toString() {
7976 f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	344	int iMax = array.length - 1;
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	345	if (iMax == -1)
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	346	return "[]";
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	347
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	348	StringBuilder b = new StringBuilder();
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	349	b.append('[');
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	350	for (int i = 0; ; i++) {
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	351	b.append(get(i));
7976 f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	352	if (i == iMax)
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	353	return b.append(']').toString();
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	354	b.append(',').append(' ');
f273c0d04215 7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011 dl parents: 5506 diff changeset	355	}
2 90ce3da70b43 Initial load duke parents: diff changeset	356	}
90ce3da70b43 Initial load duke parents: diff changeset	357
39725 9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	358	// jdk9
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	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	361	* Returns the current value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	362	* with memory semantics of reading as if the variable was declared
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	363	* non-{@code volatile}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	364	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	365	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	366	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	367	* @since 9
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	public final long getPlain(int i) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	370	return (long)AA.get(array, i);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	371	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	372
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	373	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	374	* Sets the element at index {@code i} to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	375	* with memory semantics of setting as if the variable was
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	376	* declared non-{@code volatile} and non-{@code final}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	377	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	378	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	379	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	380	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	381	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	382	public final void setPlain(int i, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	383	AA.set(array, i, newValue);
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	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	387	* Returns the current value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	388	* 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	389	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	390	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	391	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	392	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	393	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	394	public final long getOpaque(int i) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	395	return (long)AA.getOpaque(array, i);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	396	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	397
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	* Sets the element at index {@code i} to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	400	* 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	401	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	402	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	403	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	404	* @since 9
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	public final void setOpaque(int i, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	407	AA.setOpaque(array, i, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	408	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	409
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	* Returns the current value of the element at index {@code i},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	412	* 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	413	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	414	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	415	* @return the value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	416	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	417	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	418	public final long getAcquire(int i) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	419	return (long)AA.getAcquire(array, i);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	420	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	421
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	422	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	423	* Sets the element at index {@code i} to {@code newValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	424	* 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	425	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	426	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	427	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	428	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	429	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	430	public final void setRelease(int i, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	431	AA.setRelease(array, i, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	432	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	433
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	434	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	435	* Atomically sets the element at index {@code i} to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	436	* if the element's current value, referred to as the <em>witness
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	437	* value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	438	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	439	* {@link VarHandle#compareAndExchange}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	440	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	441	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	442	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	443	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	444	* @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	445	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	446	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	447	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	448	public final long compareAndExchange(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	449	return (long)AA.compareAndExchange(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	450	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	451
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	452	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	453	* Atomically sets the element at index {@code i} to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	454	* if the element's current value, referred to as the <em>witness
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	455	* value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	456	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	457	* {@link VarHandle#compareAndExchangeAcquire}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	458	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	459	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	460	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	461	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	462	* @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	463	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	464	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	465	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	466	public final long compareAndExchangeAcquire(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	467	return (long)AA.compareAndExchangeAcquire(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	468	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	469
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	470	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	471	* Atomically sets the element at index {@code i} to {@code newValue}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	472	* if the element's current value, referred to as the <em>witness
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	473	* value</em>, {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	474	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	475	* {@link VarHandle#compareAndExchangeRelease}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	476	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	477	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	478	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	479	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	480	* @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	481	* expected value if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	482	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	483	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	484	public final long compareAndExchangeRelease(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	485	return (long)AA.compareAndExchangeRelease(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	486	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	487
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	488	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	489	* Possibly atomically sets the element at index {@code i} to
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	490	* {@code newValue} if the element's current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	491	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	492	* {@link VarHandle#weakCompareAndSetVolatile}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	493	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	494	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	495	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	496	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	497	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	498	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	499	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	500	public final boolean weakCompareAndSetVolatile(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	501	return AA.weakCompareAndSetVolatile(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	502	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	503
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	504	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	505	* Possibly atomically sets the element at index {@code i} to
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	506	* {@code newValue} if the element's current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	507	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	508	* {@link VarHandle#weakCompareAndSetAcquire}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	509	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	510	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	511	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	512	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	513	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	514	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	515	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	516	public final boolean weakCompareAndSetAcquire(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	517	return AA.weakCompareAndSetAcquire(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	518	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	519
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	520	/**
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	521	* Possibly atomically sets the element at index {@code i} to
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	522	* {@code newValue} if the element's current value {@code == expectedValue},
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	523	* with memory effects as specified by
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	524	* {@link VarHandle#weakCompareAndSetRelease}.
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	525	*
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	526	* @param i the index
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	527	* @param expectedValue the expected value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	528	* @param newValue the new value
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	529	* @return {@code true} if successful
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	530	* @since 9
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	531	*/
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	532	public final boolean weakCompareAndSetRelease(int i, long expectedValue, long newValue) {
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	533	return AA.weakCompareAndSetRelease(array, i, expectedValue, newValue);
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	534	}
9548f8d846e9 8080603: Replace Unsafe with VarHandle in java.util.concurrent classes dl parents: 36936 diff changeset	535
2 90ce3da70b43 Initial load duke parents: diff changeset	536	}

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