1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Sun designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Sun in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
22 * have any questions.
23 */
24
25 /*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/licenses/publicdomain
34 */
35
36 package java.util.concurrent.atomic;
37 import sun.misc.Unsafe;
38
39 /**
40 * An {@code int} value that may be updated atomically. See the
41 * {@link java.util.concurrent.atomic} package specification for
42 * description of the properties of atomic variables. An
43 * {@code AtomicInteger} is used in applications such as atomically
44 * incremented counters, and cannot be used as a replacement for an
45 * {@link java.lang.Integer}. However, this class does extend
46 * {@code Number} to allow uniform access by tools and utilities that
47 * deal with numerically-based classes.
48 *
49 * @since 1.5
50 * @author Doug Lea
51 */
52 public class AtomicInteger extends Number implements java.io.Serializable {
53 private static final long serialVersionUID = 6214790243416807050L;
54
55 // setup to use Unsafe.compareAndSwapInt for updates
56 private static final Unsafe unsafe = Unsafe.getUnsafe();
57 private static final long valueOffset;
58
59 static {
60 try {
61 valueOffset = unsafe.objectFieldOffset
62 (AtomicInteger.class.getDeclaredField("value"));
63 } catch (Exception ex) { throw new Error(ex); }
64 }
65
66 private volatile int value;
67
68 /**
69 * Creates a new AtomicInteger with the given initial value.
70 *
71 * @param initialValue the initial value
72 */
73 public AtomicInteger(int initialValue) {
74 value = initialValue;
75 }
76
77 /**
78 * Creates a new AtomicInteger with initial value {@code 0}.
79 */
80 public AtomicInteger() {
81 }
82
83 /**
84 * Gets the current value.
85 *
86 * @return the current value
87 */
88 public final int get() {
89 return value;
90 }
91
92 /**
93 * Sets to the given value.
94 *
95 * @param newValue the new value
96 */
97 public final void set(int newValue) {
98 value = newValue;
99 }
100
101 /**
102 * Eventually sets to the given value.
103 *
104 * @param newValue the new value
105 * @since 1.6
106 */
107 public final void lazySet(int newValue) {
108 unsafe.putOrderedInt(this, valueOffset, newValue);
109 }
110
111 /**
112 * Atomically sets to the given value and returns the old value.
113 *
114 * @param newValue the new value
115 * @return the previous value
116 */
117 public final int getAndSet(int newValue) {
118 for (;;) {
119 int current = get();
120 if (compareAndSet(current, newValue))
121 return current;
122 }
123 }
124
125 /**
126 * Atomically sets the value to the given updated value
127 * if the current value {@code ==} the expected value.
128 *
129 * @param expect the expected value
130 * @param update the new value
131 * @return true if successful. False return indicates that
132 * the actual value was not equal to the expected value.
133 */
134 public final boolean compareAndSet(int expect, int update) {
135 return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
136 }
137
138 /**
139 * Atomically sets the value to the given updated value
140 * if the current value {@code ==} the expected value.
141 *
142 * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
143 * and does not provide ordering guarantees, so is only rarely an
144 * appropriate alternative to {@code compareAndSet}.
145 *
146 * @param expect the expected value
147 * @param update the new value
148 * @return true if successful.
149 */
150 public final boolean weakCompareAndSet(int expect, int update) {
151 return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
152 }
153
154 /**
155 * Atomically increments by one the current value.
156 *
157 * @return the previous value
158 */
159 public final int getAndIncrement() {
160 for (;;) {
161 int current = get();
162 int next = current + 1;
163 if (compareAndSet(current, next))
164 return current;
165 }
166 }
167
168 /**
169 * Atomically decrements by one the current value.
170 *
171 * @return the previous value
172 */
173 public final int getAndDecrement() {
174 for (;;) {
175 int current = get();
176 int next = current - 1;
177 if (compareAndSet(current, next))
178 return current;
179 }
180 }
181
182 /**
183 * Atomically adds the given value to the current value.
184 *
185 * @param delta the value to add
186 * @return the previous value
187 */
188 public final int getAndAdd(int delta) {
189 for (;;) {
190 int current = get();
191 int next = current + delta;
192 if (compareAndSet(current, next))
193 return current;
194 }
195 }
196
197 /**
198 * Atomically increments by one the current value.
199 *
200 * @return the updated value
201 */
202 public final int incrementAndGet() {
203 for (;;) {
204 int current = get();
205 int next = current + 1;
206 if (compareAndSet(current, next))
207 return next;
208 }
209 }
210
211 /**
212 * Atomically decrements by one the current value.
213 *
214 * @return the updated value
215 */
216 public final int decrementAndGet() {
217 for (;;) {
218 int current = get();
219 int next = current - 1;
220 if (compareAndSet(current, next))
221 return next;
222 }
223 }
224
225 /**
226 * Atomically adds the given value to the current value.
227 *
228 * @param delta the value to add
229 * @return the updated value
230 */
231 public final int addAndGet(int delta) {
232 for (;;) {
233 int current = get();
234 int next = current + delta;
235 if (compareAndSet(current, next))
236 return next;
237 }
238 }
239
240 /**
241 * Returns the String representation of the current value.
242 * @return the String representation of the current value.
243 */
244 public String toString() {
245 return Integer.toString(get());
246 }
247
248
249 public int intValue() {
250 return get();
251 }
252
253 public long longValue() {
254 return (long)get();
255 }
256
257 public float floatValue() {
258 return (float)get();
259 }
260
261 public double doubleValue() {
262 return (double)get();
263 }
264
265 }
Save This Page