src/share/classes/java/util/concurrent/atomic/AtomicLong.java

Print this page




 112         value = newValue;
 113     }
 114 
 115     /**
 116      * Eventually sets to the given value.
 117      *
 118      * @param newValue the new value
 119      * @since 1.6
 120      */
 121     public final void lazySet(long newValue) {
 122         unsafe.putOrderedLong(this, valueOffset, newValue);
 123     }
 124 
 125     /**
 126      * Atomically sets to the given value and returns the old value.
 127      *
 128      * @param newValue the new value
 129      * @return the previous value
 130      */
 131     public final long getAndSet(long newValue) {
 132         while (true) {
 133             long current = get();
 134             if (compareAndSet(current, newValue))
 135                 return current;
 136         }
 137     }
 138 
 139     /**
 140      * Atomically sets the value to the given updated value
 141      * if the current value {@code ==} the expected value.
 142      *
 143      * @param expect the expected value
 144      * @param update the new value
 145      * @return true if successful. False return indicates that
 146      * the actual value was not equal to the expected value.
 147      */
 148     public final boolean compareAndSet(long expect, long update) {
 149         return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
 150     }
 151 
 152     /**
 153      * Atomically sets the value to the given updated value
 154      * if the current value {@code ==} the expected value.
 155      *
 156      * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
 157      * and does not provide ordering guarantees, so is only rarely an
 158      * appropriate alternative to {@code compareAndSet}.
 159      *
 160      * @param expect the expected value
 161      * @param update the new value
 162      * @return true if successful.
 163      */
 164     public final boolean weakCompareAndSet(long expect, long update) {
 165         return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
 166     }
 167 
 168     /**
 169      * Atomically increments by one the current value.
 170      *
 171      * @return the previous value
 172      */
 173     public final long getAndIncrement() {
 174         while (true) {
 175             long current = get();
 176             long next = current + 1;
 177             if (compareAndSet(current, next))
 178                 return current;
 179         }
 180     }
 181 
 182     /**
 183      * Atomically decrements by one the current value.
 184      *
 185      * @return the previous value
 186      */
 187     public final long getAndDecrement() {
 188         while (true) {
 189             long current = get();
 190             long next = current - 1;
 191             if (compareAndSet(current, next))
 192                 return current;
 193         }
 194     }
 195 
 196     /**
 197      * Atomically adds the given value to the current value.
 198      *
 199      * @param delta the value to add
 200      * @return the previous value
 201      */
 202     public final long getAndAdd(long delta) {
 203         while (true) {
 204             long current = get();
 205             long next = current + delta;
 206             if (compareAndSet(current, next))
 207                 return current;
 208         }
 209     }
 210 
 211     /**
 212      * Atomically increments by one the current value.
 213      *
 214      * @return the updated value
 215      */
 216     public final long incrementAndGet() {
 217         for (;;) {
 218             long current = get();
 219             long next = current + 1;
 220             if (compareAndSet(current, next))
 221                 return next;
 222         }
 223     }
 224 
 225     /**
 226      * Atomically decrements by one the current value.
 227      *
 228      * @return the updated value
 229      */
 230     public final long decrementAndGet() {
 231         for (;;) {
 232             long current = get();
 233             long next = current - 1;
 234             if (compareAndSet(current, next))
 235                 return next;
 236         }
 237     }
 238 
 239     /**
 240      * Atomically adds the given value to the current value.
 241      *
 242      * @param delta the value to add
 243      * @return the updated value
 244      */
 245     public final long addAndGet(long delta) {
 246         for (;;) {
 247             long current = get();
 248             long next = current + delta;
 249             if (compareAndSet(current, next))
 250                 return next;
 251         }
 252     }
 253 
 254     /**
 255      * Returns the String representation of the current value.
 256      * @return the String representation of the current value.
 257      */
 258     public String toString() {
 259         return Long.toString(get());
 260     }
 261 
 262     /**
 263      * Returns the value of this {@code AtomicLong} as an {@code int}
 264      * after a narrowing primitive conversion.
 265      * @jls 5.1.3 Narrowing Primitive Conversions
 266      */
 267     public int intValue() {
 268         return (int)get();
 269     }
 270 
 271     /**
 272      * Returns the value of this {@code AtomicLong} as a {@code long}.
 273      */
 274     public long longValue() {
 275         return get();
 276     }


 112         value = newValue;
 113     }
 114 
 115     /**
 116      * Eventually sets to the given value.
 117      *
 118      * @param newValue the new value
 119      * @since 1.6
 120      */
 121     public final void lazySet(long newValue) {
 122         unsafe.putOrderedLong(this, valueOffset, newValue);
 123     }
 124 
 125     /**
 126      * Atomically sets to the given value and returns the old value.
 127      *
 128      * @param newValue the new value
 129      * @return the previous value
 130      */
 131     public final long getAndSet(long newValue) {
 132         return unsafe.getAndSetLong(this, valueOffset, newValue);



 133     }

 134 
 135     /**
 136      * Atomically sets the value to the given updated value
 137      * if the current value {@code ==} the expected value.
 138      *
 139      * @param expect the expected value
 140      * @param update the new value
 141      * @return true if successful. False return indicates that
 142      * the actual value was not equal to the expected value.
 143      */
 144     public final boolean compareAndSet(long expect, long update) {
 145         return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
 146     }
 147 
 148     /**
 149      * Atomically sets the value to the given updated value
 150      * if the current value {@code ==} the expected value.
 151      *
 152      * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
 153      * and does not provide ordering guarantees, so is only rarely an
 154      * appropriate alternative to {@code compareAndSet}.
 155      *
 156      * @param expect the expected value
 157      * @param update the new value
 158      * @return true if successful
 159      */
 160     public final boolean weakCompareAndSet(long expect, long update) {
 161         return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
 162     }
 163 
 164     /**
 165      * Atomically increments by one the current value.
 166      *
 167      * @return the previous value
 168      */
 169     public final long getAndIncrement() {
 170         return getAndAdd(1);




 171     }

 172 
 173     /**
 174      * Atomically decrements by one the current value.
 175      *
 176      * @return the previous value
 177      */
 178     public final long getAndDecrement() {
 179         return getAndAdd(-1);




 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 long getAndAdd(long delta) {
 189         return unsafe.getAndAddLong(this, valueOffset, delta);




 190     }

 191 
 192     /**
 193      * Atomically increments by one the current value.
 194      *
 195      * @return the updated value
 196      */
 197     public final long incrementAndGet() {
 198         return getAndAdd(1) + 1;




 199     }

 200 
 201     /**
 202      * Atomically decrements by one the current value.
 203      *
 204      * @return the updated value
 205      */
 206     public final long decrementAndGet() {
 207         return getAndAdd(-1) - 1;




 208     }

 209 
 210     /**
 211      * Atomically adds the given value to the current value.
 212      *
 213      * @param delta the value to add
 214      * @return the updated value
 215      */
 216     public final long addAndGet(long delta) {
 217         return getAndAdd(delta) + delta;




 218     }

 219 
 220     /**
 221      * Returns the String representation of the current value.
 222      * @return the String representation of the current value
 223      */
 224     public String toString() {
 225         return Long.toString(get());
 226     }
 227 
 228     /**
 229      * Returns the value of this {@code AtomicLong} as an {@code int}
 230      * after a narrowing primitive conversion.
 231      * @jls 5.1.3 Narrowing Primitive Conversions
 232      */
 233     public int intValue() {
 234         return (int)get();
 235     }
 236 
 237     /**
 238      * Returns the value of this {@code AtomicLong} as a {@code long}.
 239      */
 240     public long longValue() {
 241         return get();
 242     }