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

*** 32,41 ****
--- 32,43 ----
   * Expert Group and released to the public domain, as explained at
   * http://creativecommons.org/publicdomain/zero/1.0/
   */
  
  package java.util.concurrent.atomic;
+ import java.util.function.LongUnaryOperator;
+ import java.util.function.LongBinaryOperator;
  import sun.misc.Unsafe;
  
  /**
   * A {@code long} array in which elements may be updated atomically.
   * See the {@link java.util.concurrent.atomic} package specification
*** 242,251 ****
--- 244,347 ----
       */
      public long addAndGet(int i, long delta) {
          return getAndAdd(i, delta) + delta;
      }
  
+     /**
+      * Atomically updates the element at index {@code i} with the results
+      * of applying the given function. The function should be
+      * side-effect-free, since it may be re-applied when attempted
+      * updates fail due to contention among threads.
+      *
+      * @param i the index
+      * @param updateFunction a side-effect-free function
+      * @return the previous value
+      * @since 1.8
+      */
+     public final long getAndUpdate(int i, LongUnaryOperator updateFunction) {
+         long offset = checkedByteOffset(i);
+         long prev, next;
+         do {
+             prev = getRaw(offset);
+             next = updateFunction.operateAsLong(prev);
+         } while (!compareAndSetRaw(offset, prev, next));
+         return prev;
+     }
+ 
+     /**
+      * Atomically updates the element at index {@code i} with the results
+      * of applying the given function. The function should be
+      * side-effect-free, since it may be re-applied when attempted
+      * updates fail due to contention among threads.
+      *
+      * @param i the index
+      * @param updateFunction a side-effect-free function
+      * @return the updated value
+      * @since 1.8
+      */
+     public final long updateAndGet(int i, LongUnaryOperator updateFunction) {
+         long offset = checkedByteOffset(i);
+         long prev, next;
+         do {
+             prev = getRaw(offset);
+             next = updateFunction.operateAsLong(prev);
+         } while (!compareAndSetRaw(offset, prev, next));
+         return next;
+     }
+ 
+     /**
+      * Atomically updates the element at index {@code i} with the results
+      * of applying the given function to the current and given values.
+      * The function should be side-effect-free, since it may be
+      * re-applied when attempted updates fail due to contention among
+      * threads.  The function is applied with the current value at index
+      * {@code i} as its first argument, and the given update as the second
+      * argument.
+      *
+      * @param i the index
+      * @param x the update value
+      * @param accumulatorFunction a side-effect-free function of two arguments
+      * @return the previous value
+      * @since 1.8
+      */
+     public final long getAndAccumulate(int i, int x,
+                                       LongBinaryOperator accumulatorFunction) {
+         long offset = checkedByteOffset(i);
+         long prev, next;
+         do {
+             prev = getRaw(offset);
+             next = accumulatorFunction.operateAsLong(prev, x);
+         } while (!compareAndSetRaw(offset, prev, next));
+         return prev;
+     }
+ 
+     /**
+      * Atomically updates the element at index {@code i} with the results
+      * of applying the given function to the current and given values.
+      * The function should be side-effect-free, since it may be
+      * re-applied when attempted updates fail due to contention among
+      * threads.  The function is applied with the current value at index
+      * {@code i} as its first argument, and the given update as the second
+      * argument.
+      *
+      * @param i the index
+      * @param x the update value
+      * @param accumulatorFunction a side-effect-free function of two arguments
+      * @return the updated value
+      * @since 1.8
+      */
+     public final long accumulateAndGet(int i, int x,
+                                       LongBinaryOperator accumulatorFunction) {
+         long offset = checkedByteOffset(i);
+         long prev, next;
+         do {
+             prev = getRaw(offset);
+             next = accumulatorFunction.operateAsLong(prev, x);
+         } while (!compareAndSetRaw(offset, prev, next));
+         return next;
+     }
+ 
      /**
       * Returns the String representation of the current values of array.
       * @return the String representation of the current values of array
       */
      public String toString() {