From 43ed24648f2dc70f2ca487f3bca7ed0db6dbedbe Mon Sep 17 00:00:00 2001 From: Przemyslaw Szczepaniak Date: Tue, 15 Mar 2016 11:11:21 +0000 Subject: [PATCH] Track libcore commit e8b323c7cb7d55be9a4df579231e44f04f53d766 Bug: 27426599 Change-Id: Ie652b5fcf37b12e477ff2929df33d32b074262d4 --- api/current.txt | 398 +++++++++++++++++++++++++++++++++++++++-- api/system-current.txt | 398 +++++++++++++++++++++++++++++++++++++++-- api/test-current.txt | 398 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 1149 insertions(+), 45 deletions(-) diff --git a/api/current.txt b/api/current.txt index 909e1e2553654..650b697418221 100644 --- a/api/current.txt +++ b/api/current.txt @@ -58270,18 +58270,28 @@ package java.util { public abstract interface Map { method public abstract void clear(); + method public default V compute(K, java.util.function.BiFunction); + method public default V computeIfAbsent(K, java.util.function.Function); + method public default V computeIfPresent(K, java.util.function.BiFunction); method public abstract boolean containsKey(java.lang.Object); method public abstract boolean containsValue(java.lang.Object); method public abstract java.util.Set> entrySet(); method public abstract boolean equals(java.lang.Object); method public default void forEach(java.util.function.BiConsumer); method public abstract V get(java.lang.Object); + method public default V getOrDefault(java.lang.Object, V); method public abstract int hashCode(); method public abstract boolean isEmpty(); method public abstract java.util.Set keySet(); + method public default V merge(K, V, java.util.function.BiFunction); method public abstract V put(K, V); method public abstract void putAll(java.util.Map); + method public default V putIfAbsent(K, V); method public abstract V remove(java.lang.Object); + method public default boolean remove(java.lang.Object, java.lang.Object); + method public default boolean replace(K, V, V); + method public default V replace(K, V); + method public default void replaceAll(java.util.function.BiFunction); method public abstract int size(); method public abstract java.util.Collection values(); } @@ -58289,6 +58299,8 @@ package java.util { public static abstract interface Map.Entry { method public static java.util.Comparator> comparingByKey(); method public static java.util.Comparator> comparingByKey(java.util.Comparator); + method public static java.util.Comparator> comparingByValue(); + method public static java.util.Comparator> comparingByValue(java.util.Comparator); method public abstract boolean equals(java.lang.Object); method public abstract K getKey(); method public abstract V getValue(); @@ -59070,6 +59082,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59133,6 +59146,78 @@ package java.util.concurrent { ctor public CancellationException(java.lang.String); } + public class CompletableFuture implements java.util.concurrent.CompletionStage java.util.concurrent.Future { + ctor public CompletableFuture(); + method public java.util.concurrent.CompletableFuture acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture allOf(java.util.concurrent.CompletableFuture...); + method public static java.util.concurrent.CompletableFuture anyOf(java.util.concurrent.CompletableFuture...); + method public java.util.concurrent.CompletableFuture applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public boolean cancel(boolean); + method public boolean complete(T); + method public boolean completeExceptionally(java.lang.Throwable); + method public static java.util.concurrent.CompletableFuture completedFuture(U); + method public java.util.concurrent.CompletableFuture exceptionally(java.util.function.Function); + method public T get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; + method public T get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; + method public T getNow(T); + method public int getNumberOfDependents(); + method public java.util.concurrent.CompletableFuture handle(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public boolean isCancelled(); + method public boolean isCompletedExceptionally(); + method public boolean isDone(); + method public T join(); + method public void obtrudeException(java.lang.Throwable); + method public void obtrudeValue(T); + method public java.util.concurrent.CompletableFuture runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAccept(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenApply(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCompose(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenRun(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture toCompletableFuture(); + method public java.util.concurrent.CompletableFuture whenComplete(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + + public static abstract interface CompletableFuture.AsynchronousCompletionTask { + } + + public class CompletionException extends java.lang.RuntimeException { + ctor protected CompletionException(); + ctor protected CompletionException(java.lang.String); + ctor public CompletionException(java.lang.String, java.lang.Throwable); + ctor public CompletionException(java.lang.Throwable); + } + public abstract interface CompletionService { method public abstract java.util.concurrent.Future poll(); method public abstract java.util.concurrent.Future poll(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; @@ -59141,20 +59226,130 @@ package java.util.concurrent { method public abstract java.util.concurrent.Future take() throws java.lang.InterruptedException; } + public abstract interface CompletionStage { + method public abstract java.util.concurrent.CompletionStage acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage exceptionally(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage handle(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAccept(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenApply(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCompose(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenRun(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletableFuture toCompletableFuture(); + method public abstract java.util.concurrent.CompletionStage whenComplete(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + public class ConcurrentHashMap extends java.util.AbstractMap implements java.util.concurrent.ConcurrentMap java.io.Serializable { ctor public ConcurrentHashMap(); ctor public ConcurrentHashMap(int); ctor public ConcurrentHashMap(java.util.Map); ctor public ConcurrentHashMap(int, float); ctor public ConcurrentHashMap(int, float, int); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public boolean contains(java.lang.Object); method public java.util.Enumeration elements(); method public java.util.Set> entrySet(); + method public void forEach(java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiFunction, java.util.function.Consumer); + method public void forEachEntry(long, java.util.function.Consumer>); + method public void forEachEntry(long, java.util.function.Function, ? extends U>, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Function, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Function, java.util.function.Consumer); + method public V getOrDefault(java.lang.Object, V); + method public java.util.concurrent.ConcurrentHashMap.KeySetView keySet(V); method public java.util.Enumeration keys(); + method public long mappingCount(); + method public V merge(K, V, java.util.function.BiFunction); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(int); method public V putIfAbsent(K, V); + method public U reduce(long, java.util.function.BiFunction, java.util.function.BiFunction); + method public java.util.Map.Entry reduceEntries(long, java.util.function.BiFunction, java.util.Map.Entry, ? extends java.util.Map.Entry>); + method public U reduceEntries(long, java.util.function.Function, ? extends U>, java.util.function.BiFunction); + method public double reduceEntriesToDouble(long, java.util.function.ToDoubleFunction>, double, java.util.function.DoubleBinaryOperator); + method public int reduceEntriesToInt(long, java.util.function.ToIntFunction>, int, java.util.function.IntBinaryOperator); + method public long reduceEntriesToLong(long, java.util.function.ToLongFunction>, long, java.util.function.LongBinaryOperator); + method public K reduceKeys(long, java.util.function.BiFunction); + method public U reduceKeys(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceKeysToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceKeysToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceKeysToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); + method public double reduceToDouble(long, java.util.function.ToDoubleBiFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceToInt(long, java.util.function.ToIntBiFunction, int, java.util.function.IntBinaryOperator); + method public long reduceToLong(long, java.util.function.ToLongBiFunction, long, java.util.function.LongBinaryOperator); + method public V reduceValues(long, java.util.function.BiFunction); + method public U reduceValues(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceValuesToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceValuesToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceValuesToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); + method public U search(long, java.util.function.BiFunction); + method public U searchEntries(long, java.util.function.Function, ? extends U>); + method public U searchKeys(long, java.util.function.Function); + method public U searchValues(long, java.util.function.Function); + } + + static abstract class ConcurrentHashMap.CollectionView implements java.util.Collection java.io.Serializable { + method public final void clear(); + method public abstract boolean contains(java.lang.Object); + method public final boolean containsAll(java.util.Collection); + method public java.util.concurrent.ConcurrentHashMap getMap(); + method public final boolean isEmpty(); + method public abstract java.util.Iterator iterator(); + method public abstract boolean remove(java.lang.Object); + method public final boolean removeAll(java.util.Collection); + method public final boolean retainAll(java.util.Collection); + method public final int size(); + method public final java.lang.Object[] toArray(); + method public final T[] toArray(T[]); + method public final java.lang.String toString(); + } + + public static class ConcurrentHashMap.KeySetView extends java.util.concurrent.ConcurrentHashMap.CollectionView implements java.io.Serializable java.util.Set { + method public boolean add(K); + method public boolean addAll(java.util.Collection); + method public boolean contains(java.lang.Object); + method public void forEach(java.util.function.Consumer); + method public V getMappedValue(); + method public java.util.Iterator iterator(); + method public boolean remove(java.lang.Object); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedDeque extends java.util.AbstractCollection implements java.util.Deque java.io.Serializable { @@ -59184,6 +59379,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedQueue extends java.util.AbstractQueue implements java.util.Queue java.io.Serializable { @@ -59194,6 +59390,7 @@ package java.util.concurrent { method public E peek(); method public E poll(); method public int size(); + method public java.util.Spliterator spliterator(); } public abstract interface ConcurrentMap implements java.util.Map { @@ -59225,6 +59422,9 @@ package java.util.concurrent { method public K ceilingKey(K); method public java.util.concurrent.ConcurrentSkipListMap clone(); method public java.util.Comparator comparator(); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public java.util.NavigableSet descendingKeySet(); method public java.util.concurrent.ConcurrentNavigableMap descendingMap(); method public java.util.Set> entrySet(); @@ -59232,6 +59432,8 @@ package java.util.concurrent { method public K firstKey(); method public java.util.Map.Entry floorEntry(K); method public K floorKey(K); + method public void forEach(java.util.function.BiConsumer); + method public V getOrDefault(java.lang.Object, V); method public java.util.concurrent.ConcurrentNavigableMap headMap(K, boolean); method public java.util.concurrent.ConcurrentNavigableMap headMap(K); method public java.util.Map.Entry higherEntry(K); @@ -59240,6 +59442,7 @@ package java.util.concurrent { method public K lastKey(); method public java.util.Map.Entry lowerEntry(K); method public K lowerKey(K); + method public V merge(K, V, java.util.function.BiFunction); method public java.util.NavigableSet navigableKeySet(); method public java.util.Map.Entry pollFirstEntry(); method public java.util.Map.Entry pollLastEntry(); @@ -59247,6 +59450,7 @@ package java.util.concurrent { method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, boolean, K, boolean); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, K); method public java.util.concurrent.ConcurrentNavigableMap tailMap(K, boolean); @@ -59274,6 +59478,7 @@ package java.util.concurrent { method public E pollFirst(); method public E pollLast(); method public int size(); + method public java.util.Spliterator spliterator(); method public java.util.NavigableSet subSet(E, boolean, E, boolean); method public java.util.NavigableSet subSet(E, E); method public java.util.NavigableSet tailSet(E, boolean); @@ -59284,31 +59489,35 @@ package java.util.concurrent { ctor public CopyOnWriteArrayList(); ctor public CopyOnWriteArrayList(java.util.Collection); ctor public CopyOnWriteArrayList(E[]); - method public synchronized boolean add(E); - method public synchronized void add(int, E); - method public synchronized boolean addAll(java.util.Collection); - method public synchronized boolean addAll(int, java.util.Collection); - method public synchronized int addAllAbsent(java.util.Collection); - method public synchronized boolean addIfAbsent(E); - method public synchronized void clear(); + method public boolean add(E); + method public void add(int, E); + method public boolean addAll(java.util.Collection); + method public boolean addAll(int, java.util.Collection); + method public int addAllAbsent(java.util.Collection); + method public boolean addIfAbsent(E); + method public void clear(); method public java.lang.Object clone(); method public boolean contains(java.lang.Object); method public boolean containsAll(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public E get(int); - method public int indexOf(E, int); method public int indexOf(java.lang.Object); + method public int indexOf(E, int); method public boolean isEmpty(); method public java.util.Iterator iterator(); - method public int lastIndexOf(E, int); method public int lastIndexOf(java.lang.Object); - method public java.util.ListIterator listIterator(int); + method public int lastIndexOf(E, int); method public java.util.ListIterator listIterator(); - method public synchronized E remove(int); - method public synchronized boolean remove(java.lang.Object); - method public synchronized boolean removeAll(java.util.Collection); - method public synchronized boolean retainAll(java.util.Collection); - method public synchronized E set(int, E); + method public java.util.ListIterator listIterator(int); + method public E remove(int); + method public boolean remove(java.lang.Object); + method public boolean removeAll(java.util.Collection); + method public boolean removeIf(java.util.function.Predicate); + method public void replaceAll(java.util.function.UnaryOperator); + method public boolean retainAll(java.util.Collection); + method public E set(int, E); method public int size(); + method public void sort(java.util.Comparator); method public java.util.List subList(int, int); method public java.lang.Object[] toArray(); method public T[] toArray(T[]); @@ -59317,8 +59526,11 @@ package java.util.concurrent { public class CopyOnWriteArraySet extends java.util.AbstractSet implements java.io.Serializable { ctor public CopyOnWriteArraySet(); ctor public CopyOnWriteArraySet(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public java.util.Iterator iterator(); + method public boolean removeIf(java.util.function.Predicate); method public int size(); + method public java.util.Spliterator spliterator(); } public class CountDownLatch { @@ -59329,6 +59541,32 @@ package java.util.concurrent { method public long getCount(); } + public abstract class CountedCompleter extends java.util.concurrent.ForkJoinTask { + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter, int); + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter); + ctor protected CountedCompleter(); + method public final void addToPendingCount(int); + method public final boolean compareAndSetPendingCount(int, int); + method public void complete(T); + method public abstract void compute(); + method public final int decrementPendingCountUnlessZero(); + method protected final boolean exec(); + method public final java.util.concurrent.CountedCompleter firstComplete(); + method public final java.util.concurrent.CountedCompleter getCompleter(); + method public final int getPendingCount(); + method public T getRawResult(); + method public final java.util.concurrent.CountedCompleter getRoot(); + method public final void helpComplete(int); + method public final java.util.concurrent.CountedCompleter nextComplete(); + method public void onCompletion(java.util.concurrent.CountedCompleter); + method public boolean onExceptionalCompletion(java.lang.Throwable, java.util.concurrent.CountedCompleter); + method public final void propagateCompletion(); + method public final void quietlyCompleteRoot(); + method public final void setPendingCount(int); + method protected void setRawResult(T); + method public final void tryComplete(); + } + public class CyclicBarrier { ctor public CyclicBarrier(int, java.lang.Runnable); ctor public CyclicBarrier(int); @@ -59419,6 +59657,8 @@ package java.util.concurrent { method public static java.util.concurrent.ExecutorService newSingleThreadExecutor(java.util.concurrent.ThreadFactory); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(int); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(); method public static java.util.concurrent.Callable privilegedCallable(java.util.concurrent.Callable); method public static java.util.concurrent.Callable privilegedCallableUsingCurrentClassLoader(java.util.concurrent.Callable); method public static java.util.concurrent.ThreadFactory privilegedThreadFactory(); @@ -59432,11 +59672,13 @@ package java.util.concurrent { ctor public ForkJoinPool(int, java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory, java.lang.Thread.UncaughtExceptionHandler, boolean); method public boolean awaitQuiescence(long, java.util.concurrent.TimeUnit); method public boolean awaitTermination(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public static java.util.concurrent.ForkJoinPool commonPool(); method protected int drainTasksTo(java.util.Collection>); method public void execute(java.util.concurrent.ForkJoinTask); method public void execute(java.lang.Runnable); method public int getActiveThreadCount(); method public boolean getAsyncMode(); + method public static int getCommonPoolParallelism(); method public java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory getFactory(); method public int getParallelism(); method public int getPoolSize(); @@ -59474,6 +59716,7 @@ package java.util.concurrent { method public static java.util.concurrent.ForkJoinTask adapt(java.lang.Runnable, T); method public static java.util.concurrent.ForkJoinTask adapt(java.util.concurrent.Callable); method public boolean cancel(boolean); + method public final boolean compareAndSetForkJoinTaskTag(short, short); method public void complete(V); method public void completeExceptionally(java.lang.Throwable); method protected abstract boolean exec(); @@ -59481,6 +59724,7 @@ package java.util.concurrent { method public final V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; method public final V get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; method public final java.lang.Throwable getException(); + method public final short getForkJoinTaskTag(); method public static java.util.concurrent.ForkJoinPool getPool(); method public static int getQueuedTaskCount(); method public abstract V getRawResult(); @@ -59499,9 +59743,11 @@ package java.util.concurrent { method protected static java.util.concurrent.ForkJoinTask peekNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollTask(); + method public final void quietlyComplete(); method public final void quietlyInvoke(); method public final void quietlyJoin(); method public void reinitialize(); + method public final short setForkJoinTaskTag(short); method protected abstract void setRawResult(V); method public boolean tryUnfork(); } @@ -59575,6 +59821,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public E takeFirst() throws java.lang.InterruptedException; method public E takeLast() throws java.lang.InterruptedException; @@ -59595,6 +59842,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59614,6 +59862,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public void transfer(E) throws java.lang.InterruptedException; method public boolean tryTransfer(E); @@ -59661,6 +59910,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59764,6 +60014,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59893,112 +60144,136 @@ package java.util.concurrent.atomic { public class AtomicInteger extends java.lang.Number implements java.io.Serializable { ctor public AtomicInteger(int); ctor public AtomicInteger(); + method public final int accumulateAndGet(int, java.util.function.IntBinaryOperator); method public final int addAndGet(int); method public final boolean compareAndSet(int, int); method public final int decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final int get(); + method public final int getAndAccumulate(int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int); method public final int getAndDecrement(); method public final int getAndIncrement(); method public final int getAndSet(int); + method public final int getAndUpdate(java.util.function.IntUnaryOperator); method public final int incrementAndGet(); method public int intValue(); method public final void lazySet(int); method public long longValue(); method public final void set(int); + method public final int updateAndGet(java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int); } public class AtomicIntegerArray implements java.io.Serializable { ctor public AtomicIntegerArray(int); ctor public AtomicIntegerArray(int[]); + method public final int accumulateAndGet(int, int, java.util.function.IntBinaryOperator); method public final int addAndGet(int, int); method public final boolean compareAndSet(int, int, int); method public final int decrementAndGet(int); method public final int get(int); + method public final int getAndAccumulate(int, int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int, int); method public final int getAndDecrement(int); method public final int getAndIncrement(int); method public final int getAndSet(int, int); + method public final int getAndUpdate(int, java.util.function.IntUnaryOperator); method public final int incrementAndGet(int); method public final void lazySet(int, int); method public final int length(); method public final void set(int, int); + method public final int updateAndGet(int, java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int, int); } public abstract class AtomicIntegerFieldUpdater { ctor protected AtomicIntegerFieldUpdater(); + method public final int accumulateAndGet(T, int, java.util.function.IntBinaryOperator); method public int addAndGet(T, int); method public abstract boolean compareAndSet(T, int, int); method public int decrementAndGet(T); method public abstract int get(T); + method public final int getAndAccumulate(T, int, java.util.function.IntBinaryOperator); method public int getAndAdd(T, int); method public int getAndDecrement(T); method public int getAndIncrement(T); method public int getAndSet(T, int); + method public final int getAndUpdate(T, java.util.function.IntUnaryOperator); method public int incrementAndGet(T); method public abstract void lazySet(T, int); method public static java.util.concurrent.atomic.AtomicIntegerFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, int); + method public final int updateAndGet(T, java.util.function.IntUnaryOperator); method public abstract boolean weakCompareAndSet(T, int, int); } public class AtomicLong extends java.lang.Number implements java.io.Serializable { ctor public AtomicLong(long); ctor public AtomicLong(); + method public final long accumulateAndGet(long, java.util.function.LongBinaryOperator); method public final long addAndGet(long); method public final boolean compareAndSet(long, long); method public final long decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final long get(); + method public final long getAndAccumulate(long, java.util.function.LongBinaryOperator); method public final long getAndAdd(long); method public final long getAndDecrement(); method public final long getAndIncrement(); method public final long getAndSet(long); + method public final long getAndUpdate(java.util.function.LongUnaryOperator); method public final long incrementAndGet(); method public int intValue(); method public final void lazySet(long); method public long longValue(); method public final void set(long); + method public final long updateAndGet(java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(long, long); } public class AtomicLongArray implements java.io.Serializable { ctor public AtomicLongArray(int); ctor public AtomicLongArray(long[]); + method public final long accumulateAndGet(int, long, java.util.function.LongBinaryOperator); method public long addAndGet(int, long); method public final boolean compareAndSet(int, long, long); method public final long decrementAndGet(int); method public final long get(int); + method public final long getAndAccumulate(int, long, java.util.function.LongBinaryOperator); method public final long getAndAdd(int, long); method public final long getAndDecrement(int); method public final long getAndIncrement(int); method public final long getAndSet(int, long); + method public final long getAndUpdate(int, java.util.function.LongUnaryOperator); method public final long incrementAndGet(int); method public final void lazySet(int, long); method public final int length(); method public final void set(int, long); + method public final long updateAndGet(int, java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(int, long, long); } public abstract class AtomicLongFieldUpdater { ctor protected AtomicLongFieldUpdater(); + method public final long accumulateAndGet(T, long, java.util.function.LongBinaryOperator); method public long addAndGet(T, long); method public abstract boolean compareAndSet(T, long, long); method public long decrementAndGet(T); method public abstract long get(T); + method public final long getAndAccumulate(T, long, java.util.function.LongBinaryOperator); method public long getAndAdd(T, long); method public long getAndDecrement(T); method public long getAndIncrement(T); method public long getAndSet(T, long); + method public final long getAndUpdate(T, java.util.function.LongUnaryOperator); method public long incrementAndGet(T); method public abstract void lazySet(T, long); method public static java.util.concurrent.atomic.AtomicLongFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, long); + method public final long updateAndGet(T, java.util.function.LongUnaryOperator); method public abstract boolean weakCompareAndSet(T, long, long); } @@ -60016,34 +60291,46 @@ package java.util.concurrent.atomic { public class AtomicReference implements java.io.Serializable { ctor public AtomicReference(V); ctor public AtomicReference(); + method public final V accumulateAndGet(V, java.util.function.BinaryOperator); method public final boolean compareAndSet(V, V); method public final V get(); + method public final V getAndAccumulate(V, java.util.function.BinaryOperator); method public final V getAndSet(V); + method public final V getAndUpdate(java.util.function.UnaryOperator); method public final void lazySet(V); method public final void set(V); + method public final V updateAndGet(java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(V, V); } public class AtomicReferenceArray implements java.io.Serializable { ctor public AtomicReferenceArray(int); ctor public AtomicReferenceArray(E[]); + method public final E accumulateAndGet(int, E, java.util.function.BinaryOperator); method public final boolean compareAndSet(int, E, E); method public final E get(int); + method public final E getAndAccumulate(int, E, java.util.function.BinaryOperator); method public final E getAndSet(int, E); + method public final E getAndUpdate(int, java.util.function.UnaryOperator); method public final void lazySet(int, E); method public final int length(); method public final void set(int, E); + method public final E updateAndGet(int, java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(int, E, E); } public abstract class AtomicReferenceFieldUpdater { ctor protected AtomicReferenceFieldUpdater(); + method public final V accumulateAndGet(T, V, java.util.function.BinaryOperator); method public abstract boolean compareAndSet(T, V, V); method public abstract V get(T); + method public final V getAndAccumulate(T, V, java.util.function.BinaryOperator); method public V getAndSet(T, V); + method public final V getAndUpdate(T, java.util.function.UnaryOperator); method public abstract void lazySet(T, V); method public static java.util.concurrent.atomic.AtomicReferenceFieldUpdater newUpdater(java.lang.Class, java.lang.Class, java.lang.String); method public abstract void set(T, V); + method public final V updateAndGet(T, java.util.function.UnaryOperator); method public abstract boolean weakCompareAndSet(T, V, V); } @@ -60058,6 +60345,59 @@ package java.util.concurrent.atomic { method public boolean weakCompareAndSet(V, V, int, int); } + public class DoubleAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAccumulator(java.util.function.DoubleBinaryOperator, double); + method public void accumulate(double); + method public double doubleValue(); + method public float floatValue(); + method public double get(); + method public double getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class DoubleAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAdder(); + method public void add(double); + method public double doubleValue(); + method public float floatValue(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public double sum(); + method public double sumThenReset(); + } + + public class LongAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAccumulator(java.util.function.LongBinaryOperator, long); + method public void accumulate(long); + method public double doubleValue(); + method public float floatValue(); + method public long get(); + method public long getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class LongAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAdder(); + method public void add(long); + method public void decrement(); + method public double doubleValue(); + method public float floatValue(); + method public void increment(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public long sum(); + method public long sumThenReset(); + } + + abstract class Striped64 extends java.lang.Number { + } + } package java.util.concurrent.locks { @@ -60265,6 +60605,34 @@ package java.util.concurrent.locks { method public void unlock(); } + public class StampedLock implements java.io.Serializable { + ctor public StampedLock(); + method public java.util.concurrent.locks.Lock asReadLock(); + method public java.util.concurrent.locks.ReadWriteLock asReadWriteLock(); + method public java.util.concurrent.locks.Lock asWriteLock(); + method public int getReadLockCount(); + method public boolean isReadLocked(); + method public boolean isWriteLocked(); + method public long readLock(); + method public long readLockInterruptibly() throws java.lang.InterruptedException; + method public long tryConvertToOptimisticRead(long); + method public long tryConvertToReadLock(long); + method public long tryConvertToWriteLock(long); + method public long tryOptimisticRead(); + method public long tryReadLock(); + method public long tryReadLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public boolean tryUnlockRead(); + method public boolean tryUnlockWrite(); + method public long tryWriteLock(); + method public long tryWriteLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public void unlock(long); + method public void unlockRead(long); + method public void unlockWrite(long); + method public boolean validate(long); + method public long writeLock(); + method public long writeLockInterruptibly() throws java.lang.InterruptedException; + } + } package java.util.function { diff --git a/api/system-current.txt b/api/system-current.txt index 8c32897ac40ad..87424d6a4eec8 100644 --- a/api/system-current.txt +++ b/api/system-current.txt @@ -61370,18 +61370,28 @@ package java.util { public abstract interface Map { method public abstract void clear(); + method public default V compute(K, java.util.function.BiFunction); + method public default V computeIfAbsent(K, java.util.function.Function); + method public default V computeIfPresent(K, java.util.function.BiFunction); method public abstract boolean containsKey(java.lang.Object); method public abstract boolean containsValue(java.lang.Object); method public abstract java.util.Set> entrySet(); method public abstract boolean equals(java.lang.Object); method public default void forEach(java.util.function.BiConsumer); method public abstract V get(java.lang.Object); + method public default V getOrDefault(java.lang.Object, V); method public abstract int hashCode(); method public abstract boolean isEmpty(); method public abstract java.util.Set keySet(); + method public default V merge(K, V, java.util.function.BiFunction); method public abstract V put(K, V); method public abstract void putAll(java.util.Map); + method public default V putIfAbsent(K, V); method public abstract V remove(java.lang.Object); + method public default boolean remove(java.lang.Object, java.lang.Object); + method public default boolean replace(K, V, V); + method public default V replace(K, V); + method public default void replaceAll(java.util.function.BiFunction); method public abstract int size(); method public abstract java.util.Collection values(); } @@ -61389,6 +61399,8 @@ package java.util { public static abstract interface Map.Entry { method public static java.util.Comparator> comparingByKey(); method public static java.util.Comparator> comparingByKey(java.util.Comparator); + method public static java.util.Comparator> comparingByValue(); + method public static java.util.Comparator> comparingByValue(java.util.Comparator); method public abstract boolean equals(java.lang.Object); method public abstract K getKey(); method public abstract V getValue(); @@ -62170,6 +62182,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -62233,6 +62246,78 @@ package java.util.concurrent { ctor public CancellationException(java.lang.String); } + public class CompletableFuture implements java.util.concurrent.CompletionStage java.util.concurrent.Future { + ctor public CompletableFuture(); + method public java.util.concurrent.CompletableFuture acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture allOf(java.util.concurrent.CompletableFuture...); + method public static java.util.concurrent.CompletableFuture anyOf(java.util.concurrent.CompletableFuture...); + method public java.util.concurrent.CompletableFuture applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public boolean cancel(boolean); + method public boolean complete(T); + method public boolean completeExceptionally(java.lang.Throwable); + method public static java.util.concurrent.CompletableFuture completedFuture(U); + method public java.util.concurrent.CompletableFuture exceptionally(java.util.function.Function); + method public T get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; + method public T get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; + method public T getNow(T); + method public int getNumberOfDependents(); + method public java.util.concurrent.CompletableFuture handle(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public boolean isCancelled(); + method public boolean isCompletedExceptionally(); + method public boolean isDone(); + method public T join(); + method public void obtrudeException(java.lang.Throwable); + method public void obtrudeValue(T); + method public java.util.concurrent.CompletableFuture runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAccept(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenApply(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCompose(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenRun(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture toCompletableFuture(); + method public java.util.concurrent.CompletableFuture whenComplete(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + + public static abstract interface CompletableFuture.AsynchronousCompletionTask { + } + + public class CompletionException extends java.lang.RuntimeException { + ctor protected CompletionException(); + ctor protected CompletionException(java.lang.String); + ctor public CompletionException(java.lang.String, java.lang.Throwable); + ctor public CompletionException(java.lang.Throwable); + } + public abstract interface CompletionService { method public abstract java.util.concurrent.Future poll(); method public abstract java.util.concurrent.Future poll(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; @@ -62241,20 +62326,130 @@ package java.util.concurrent { method public abstract java.util.concurrent.Future take() throws java.lang.InterruptedException; } + public abstract interface CompletionStage { + method public abstract java.util.concurrent.CompletionStage acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage exceptionally(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage handle(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAccept(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenApply(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCompose(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenRun(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletableFuture toCompletableFuture(); + method public abstract java.util.concurrent.CompletionStage whenComplete(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + public class ConcurrentHashMap extends java.util.AbstractMap implements java.util.concurrent.ConcurrentMap java.io.Serializable { ctor public ConcurrentHashMap(); ctor public ConcurrentHashMap(int); ctor public ConcurrentHashMap(java.util.Map); ctor public ConcurrentHashMap(int, float); ctor public ConcurrentHashMap(int, float, int); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public boolean contains(java.lang.Object); method public java.util.Enumeration elements(); method public java.util.Set> entrySet(); + method public void forEach(java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiFunction, java.util.function.Consumer); + method public void forEachEntry(long, java.util.function.Consumer>); + method public void forEachEntry(long, java.util.function.Function, ? extends U>, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Function, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Function, java.util.function.Consumer); + method public V getOrDefault(java.lang.Object, V); + method public java.util.concurrent.ConcurrentHashMap.KeySetView keySet(V); method public java.util.Enumeration keys(); + method public long mappingCount(); + method public V merge(K, V, java.util.function.BiFunction); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(int); method public V putIfAbsent(K, V); + method public U reduce(long, java.util.function.BiFunction, java.util.function.BiFunction); + method public java.util.Map.Entry reduceEntries(long, java.util.function.BiFunction, java.util.Map.Entry, ? extends java.util.Map.Entry>); + method public U reduceEntries(long, java.util.function.Function, ? extends U>, java.util.function.BiFunction); + method public double reduceEntriesToDouble(long, java.util.function.ToDoubleFunction>, double, java.util.function.DoubleBinaryOperator); + method public int reduceEntriesToInt(long, java.util.function.ToIntFunction>, int, java.util.function.IntBinaryOperator); + method public long reduceEntriesToLong(long, java.util.function.ToLongFunction>, long, java.util.function.LongBinaryOperator); + method public K reduceKeys(long, java.util.function.BiFunction); + method public U reduceKeys(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceKeysToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceKeysToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceKeysToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); + method public double reduceToDouble(long, java.util.function.ToDoubleBiFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceToInt(long, java.util.function.ToIntBiFunction, int, java.util.function.IntBinaryOperator); + method public long reduceToLong(long, java.util.function.ToLongBiFunction, long, java.util.function.LongBinaryOperator); + method public V reduceValues(long, java.util.function.BiFunction); + method public U reduceValues(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceValuesToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceValuesToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceValuesToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); + method public U search(long, java.util.function.BiFunction); + method public U searchEntries(long, java.util.function.Function, ? extends U>); + method public U searchKeys(long, java.util.function.Function); + method public U searchValues(long, java.util.function.Function); + } + + static abstract class ConcurrentHashMap.CollectionView implements java.util.Collection java.io.Serializable { + method public final void clear(); + method public abstract boolean contains(java.lang.Object); + method public final boolean containsAll(java.util.Collection); + method public java.util.concurrent.ConcurrentHashMap getMap(); + method public final boolean isEmpty(); + method public abstract java.util.Iterator iterator(); + method public abstract boolean remove(java.lang.Object); + method public final boolean removeAll(java.util.Collection); + method public final boolean retainAll(java.util.Collection); + method public final int size(); + method public final java.lang.Object[] toArray(); + method public final T[] toArray(T[]); + method public final java.lang.String toString(); + } + + public static class ConcurrentHashMap.KeySetView extends java.util.concurrent.ConcurrentHashMap.CollectionView implements java.io.Serializable java.util.Set { + method public boolean add(K); + method public boolean addAll(java.util.Collection); + method public boolean contains(java.lang.Object); + method public void forEach(java.util.function.Consumer); + method public V getMappedValue(); + method public java.util.Iterator iterator(); + method public boolean remove(java.lang.Object); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedDeque extends java.util.AbstractCollection implements java.util.Deque java.io.Serializable { @@ -62284,6 +62479,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedQueue extends java.util.AbstractQueue implements java.util.Queue java.io.Serializable { @@ -62294,6 +62490,7 @@ package java.util.concurrent { method public E peek(); method public E poll(); method public int size(); + method public java.util.Spliterator spliterator(); } public abstract interface ConcurrentMap implements java.util.Map { @@ -62325,6 +62522,9 @@ package java.util.concurrent { method public K ceilingKey(K); method public java.util.concurrent.ConcurrentSkipListMap clone(); method public java.util.Comparator comparator(); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public java.util.NavigableSet descendingKeySet(); method public java.util.concurrent.ConcurrentNavigableMap descendingMap(); method public java.util.Set> entrySet(); @@ -62332,6 +62532,8 @@ package java.util.concurrent { method public K firstKey(); method public java.util.Map.Entry floorEntry(K); method public K floorKey(K); + method public void forEach(java.util.function.BiConsumer); + method public V getOrDefault(java.lang.Object, V); method public java.util.concurrent.ConcurrentNavigableMap headMap(K, boolean); method public java.util.concurrent.ConcurrentNavigableMap headMap(K); method public java.util.Map.Entry higherEntry(K); @@ -62340,6 +62542,7 @@ package java.util.concurrent { method public K lastKey(); method public java.util.Map.Entry lowerEntry(K); method public K lowerKey(K); + method public V merge(K, V, java.util.function.BiFunction); method public java.util.NavigableSet navigableKeySet(); method public java.util.Map.Entry pollFirstEntry(); method public java.util.Map.Entry pollLastEntry(); @@ -62347,6 +62550,7 @@ package java.util.concurrent { method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, boolean, K, boolean); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, K); method public java.util.concurrent.ConcurrentNavigableMap tailMap(K, boolean); @@ -62374,6 +62578,7 @@ package java.util.concurrent { method public E pollFirst(); method public E pollLast(); method public int size(); + method public java.util.Spliterator spliterator(); method public java.util.NavigableSet subSet(E, boolean, E, boolean); method public java.util.NavigableSet subSet(E, E); method public java.util.NavigableSet tailSet(E, boolean); @@ -62384,31 +62589,35 @@ package java.util.concurrent { ctor public CopyOnWriteArrayList(); ctor public CopyOnWriteArrayList(java.util.Collection); ctor public CopyOnWriteArrayList(E[]); - method public synchronized boolean add(E); - method public synchronized void add(int, E); - method public synchronized boolean addAll(java.util.Collection); - method public synchronized boolean addAll(int, java.util.Collection); - method public synchronized int addAllAbsent(java.util.Collection); - method public synchronized boolean addIfAbsent(E); - method public synchronized void clear(); + method public boolean add(E); + method public void add(int, E); + method public boolean addAll(java.util.Collection); + method public boolean addAll(int, java.util.Collection); + method public int addAllAbsent(java.util.Collection); + method public boolean addIfAbsent(E); + method public void clear(); method public java.lang.Object clone(); method public boolean contains(java.lang.Object); method public boolean containsAll(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public E get(int); - method public int indexOf(E, int); method public int indexOf(java.lang.Object); + method public int indexOf(E, int); method public boolean isEmpty(); method public java.util.Iterator iterator(); - method public int lastIndexOf(E, int); method public int lastIndexOf(java.lang.Object); - method public java.util.ListIterator listIterator(int); + method public int lastIndexOf(E, int); method public java.util.ListIterator listIterator(); - method public synchronized E remove(int); - method public synchronized boolean remove(java.lang.Object); - method public synchronized boolean removeAll(java.util.Collection); - method public synchronized boolean retainAll(java.util.Collection); - method public synchronized E set(int, E); + method public java.util.ListIterator listIterator(int); + method public E remove(int); + method public boolean remove(java.lang.Object); + method public boolean removeAll(java.util.Collection); + method public boolean removeIf(java.util.function.Predicate); + method public void replaceAll(java.util.function.UnaryOperator); + method public boolean retainAll(java.util.Collection); + method public E set(int, E); method public int size(); + method public void sort(java.util.Comparator); method public java.util.List subList(int, int); method public java.lang.Object[] toArray(); method public T[] toArray(T[]); @@ -62417,8 +62626,11 @@ package java.util.concurrent { public class CopyOnWriteArraySet extends java.util.AbstractSet implements java.io.Serializable { ctor public CopyOnWriteArraySet(); ctor public CopyOnWriteArraySet(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public java.util.Iterator iterator(); + method public boolean removeIf(java.util.function.Predicate); method public int size(); + method public java.util.Spliterator spliterator(); } public class CountDownLatch { @@ -62429,6 +62641,32 @@ package java.util.concurrent { method public long getCount(); } + public abstract class CountedCompleter extends java.util.concurrent.ForkJoinTask { + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter, int); + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter); + ctor protected CountedCompleter(); + method public final void addToPendingCount(int); + method public final boolean compareAndSetPendingCount(int, int); + method public void complete(T); + method public abstract void compute(); + method public final int decrementPendingCountUnlessZero(); + method protected final boolean exec(); + method public final java.util.concurrent.CountedCompleter firstComplete(); + method public final java.util.concurrent.CountedCompleter getCompleter(); + method public final int getPendingCount(); + method public T getRawResult(); + method public final java.util.concurrent.CountedCompleter getRoot(); + method public final void helpComplete(int); + method public final java.util.concurrent.CountedCompleter nextComplete(); + method public void onCompletion(java.util.concurrent.CountedCompleter); + method public boolean onExceptionalCompletion(java.lang.Throwable, java.util.concurrent.CountedCompleter); + method public final void propagateCompletion(); + method public final void quietlyCompleteRoot(); + method public final void setPendingCount(int); + method protected void setRawResult(T); + method public final void tryComplete(); + } + public class CyclicBarrier { ctor public CyclicBarrier(int, java.lang.Runnable); ctor public CyclicBarrier(int); @@ -62519,6 +62757,8 @@ package java.util.concurrent { method public static java.util.concurrent.ExecutorService newSingleThreadExecutor(java.util.concurrent.ThreadFactory); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(int); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(); method public static java.util.concurrent.Callable privilegedCallable(java.util.concurrent.Callable); method public static java.util.concurrent.Callable privilegedCallableUsingCurrentClassLoader(java.util.concurrent.Callable); method public static java.util.concurrent.ThreadFactory privilegedThreadFactory(); @@ -62532,11 +62772,13 @@ package java.util.concurrent { ctor public ForkJoinPool(int, java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory, java.lang.Thread.UncaughtExceptionHandler, boolean); method public boolean awaitQuiescence(long, java.util.concurrent.TimeUnit); method public boolean awaitTermination(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public static java.util.concurrent.ForkJoinPool commonPool(); method protected int drainTasksTo(java.util.Collection>); method public void execute(java.util.concurrent.ForkJoinTask); method public void execute(java.lang.Runnable); method public int getActiveThreadCount(); method public boolean getAsyncMode(); + method public static int getCommonPoolParallelism(); method public java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory getFactory(); method public int getParallelism(); method public int getPoolSize(); @@ -62574,6 +62816,7 @@ package java.util.concurrent { method public static java.util.concurrent.ForkJoinTask adapt(java.lang.Runnable, T); method public static java.util.concurrent.ForkJoinTask adapt(java.util.concurrent.Callable); method public boolean cancel(boolean); + method public final boolean compareAndSetForkJoinTaskTag(short, short); method public void complete(V); method public void completeExceptionally(java.lang.Throwable); method protected abstract boolean exec(); @@ -62581,6 +62824,7 @@ package java.util.concurrent { method public final V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; method public final V get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; method public final java.lang.Throwable getException(); + method public final short getForkJoinTaskTag(); method public static java.util.concurrent.ForkJoinPool getPool(); method public static int getQueuedTaskCount(); method public abstract V getRawResult(); @@ -62599,9 +62843,11 @@ package java.util.concurrent { method protected static java.util.concurrent.ForkJoinTask peekNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollTask(); + method public final void quietlyComplete(); method public final void quietlyInvoke(); method public final void quietlyJoin(); method public void reinitialize(); + method public final short setForkJoinTaskTag(short); method protected abstract void setRawResult(V); method public boolean tryUnfork(); } @@ -62675,6 +62921,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public E takeFirst() throws java.lang.InterruptedException; method public E takeLast() throws java.lang.InterruptedException; @@ -62695,6 +62942,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -62714,6 +62962,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public void transfer(E) throws java.lang.InterruptedException; method public boolean tryTransfer(E); @@ -62761,6 +63010,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -62864,6 +63114,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -62993,112 +63244,136 @@ package java.util.concurrent.atomic { public class AtomicInteger extends java.lang.Number implements java.io.Serializable { ctor public AtomicInteger(int); ctor public AtomicInteger(); + method public final int accumulateAndGet(int, java.util.function.IntBinaryOperator); method public final int addAndGet(int); method public final boolean compareAndSet(int, int); method public final int decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final int get(); + method public final int getAndAccumulate(int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int); method public final int getAndDecrement(); method public final int getAndIncrement(); method public final int getAndSet(int); + method public final int getAndUpdate(java.util.function.IntUnaryOperator); method public final int incrementAndGet(); method public int intValue(); method public final void lazySet(int); method public long longValue(); method public final void set(int); + method public final int updateAndGet(java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int); } public class AtomicIntegerArray implements java.io.Serializable { ctor public AtomicIntegerArray(int); ctor public AtomicIntegerArray(int[]); + method public final int accumulateAndGet(int, int, java.util.function.IntBinaryOperator); method public final int addAndGet(int, int); method public final boolean compareAndSet(int, int, int); method public final int decrementAndGet(int); method public final int get(int); + method public final int getAndAccumulate(int, int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int, int); method public final int getAndDecrement(int); method public final int getAndIncrement(int); method public final int getAndSet(int, int); + method public final int getAndUpdate(int, java.util.function.IntUnaryOperator); method public final int incrementAndGet(int); method public final void lazySet(int, int); method public final int length(); method public final void set(int, int); + method public final int updateAndGet(int, java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int, int); } public abstract class AtomicIntegerFieldUpdater { ctor protected AtomicIntegerFieldUpdater(); + method public final int accumulateAndGet(T, int, java.util.function.IntBinaryOperator); method public int addAndGet(T, int); method public abstract boolean compareAndSet(T, int, int); method public int decrementAndGet(T); method public abstract int get(T); + method public final int getAndAccumulate(T, int, java.util.function.IntBinaryOperator); method public int getAndAdd(T, int); method public int getAndDecrement(T); method public int getAndIncrement(T); method public int getAndSet(T, int); + method public final int getAndUpdate(T, java.util.function.IntUnaryOperator); method public int incrementAndGet(T); method public abstract void lazySet(T, int); method public static java.util.concurrent.atomic.AtomicIntegerFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, int); + method public final int updateAndGet(T, java.util.function.IntUnaryOperator); method public abstract boolean weakCompareAndSet(T, int, int); } public class AtomicLong extends java.lang.Number implements java.io.Serializable { ctor public AtomicLong(long); ctor public AtomicLong(); + method public final long accumulateAndGet(long, java.util.function.LongBinaryOperator); method public final long addAndGet(long); method public final boolean compareAndSet(long, long); method public final long decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final long get(); + method public final long getAndAccumulate(long, java.util.function.LongBinaryOperator); method public final long getAndAdd(long); method public final long getAndDecrement(); method public final long getAndIncrement(); method public final long getAndSet(long); + method public final long getAndUpdate(java.util.function.LongUnaryOperator); method public final long incrementAndGet(); method public int intValue(); method public final void lazySet(long); method public long longValue(); method public final void set(long); + method public final long updateAndGet(java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(long, long); } public class AtomicLongArray implements java.io.Serializable { ctor public AtomicLongArray(int); ctor public AtomicLongArray(long[]); + method public final long accumulateAndGet(int, long, java.util.function.LongBinaryOperator); method public long addAndGet(int, long); method public final boolean compareAndSet(int, long, long); method public final long decrementAndGet(int); method public final long get(int); + method public final long getAndAccumulate(int, long, java.util.function.LongBinaryOperator); method public final long getAndAdd(int, long); method public final long getAndDecrement(int); method public final long getAndIncrement(int); method public final long getAndSet(int, long); + method public final long getAndUpdate(int, java.util.function.LongUnaryOperator); method public final long incrementAndGet(int); method public final void lazySet(int, long); method public final int length(); method public final void set(int, long); + method public final long updateAndGet(int, java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(int, long, long); } public abstract class AtomicLongFieldUpdater { ctor protected AtomicLongFieldUpdater(); + method public final long accumulateAndGet(T, long, java.util.function.LongBinaryOperator); method public long addAndGet(T, long); method public abstract boolean compareAndSet(T, long, long); method public long decrementAndGet(T); method public abstract long get(T); + method public final long getAndAccumulate(T, long, java.util.function.LongBinaryOperator); method public long getAndAdd(T, long); method public long getAndDecrement(T); method public long getAndIncrement(T); method public long getAndSet(T, long); + method public final long getAndUpdate(T, java.util.function.LongUnaryOperator); method public long incrementAndGet(T); method public abstract void lazySet(T, long); method public static java.util.concurrent.atomic.AtomicLongFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, long); + method public final long updateAndGet(T, java.util.function.LongUnaryOperator); method public abstract boolean weakCompareAndSet(T, long, long); } @@ -63116,34 +63391,46 @@ package java.util.concurrent.atomic { public class AtomicReference implements java.io.Serializable { ctor public AtomicReference(V); ctor public AtomicReference(); + method public final V accumulateAndGet(V, java.util.function.BinaryOperator); method public final boolean compareAndSet(V, V); method public final V get(); + method public final V getAndAccumulate(V, java.util.function.BinaryOperator); method public final V getAndSet(V); + method public final V getAndUpdate(java.util.function.UnaryOperator); method public final void lazySet(V); method public final void set(V); + method public final V updateAndGet(java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(V, V); } public class AtomicReferenceArray implements java.io.Serializable { ctor public AtomicReferenceArray(int); ctor public AtomicReferenceArray(E[]); + method public final E accumulateAndGet(int, E, java.util.function.BinaryOperator); method public final boolean compareAndSet(int, E, E); method public final E get(int); + method public final E getAndAccumulate(int, E, java.util.function.BinaryOperator); method public final E getAndSet(int, E); + method public final E getAndUpdate(int, java.util.function.UnaryOperator); method public final void lazySet(int, E); method public final int length(); method public final void set(int, E); + method public final E updateAndGet(int, java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(int, E, E); } public abstract class AtomicReferenceFieldUpdater { ctor protected AtomicReferenceFieldUpdater(); + method public final V accumulateAndGet(T, V, java.util.function.BinaryOperator); method public abstract boolean compareAndSet(T, V, V); method public abstract V get(T); + method public final V getAndAccumulate(T, V, java.util.function.BinaryOperator); method public V getAndSet(T, V); + method public final V getAndUpdate(T, java.util.function.UnaryOperator); method public abstract void lazySet(T, V); method public static java.util.concurrent.atomic.AtomicReferenceFieldUpdater newUpdater(java.lang.Class, java.lang.Class, java.lang.String); method public abstract void set(T, V); + method public final V updateAndGet(T, java.util.function.UnaryOperator); method public abstract boolean weakCompareAndSet(T, V, V); } @@ -63158,6 +63445,59 @@ package java.util.concurrent.atomic { method public boolean weakCompareAndSet(V, V, int, int); } + public class DoubleAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAccumulator(java.util.function.DoubleBinaryOperator, double); + method public void accumulate(double); + method public double doubleValue(); + method public float floatValue(); + method public double get(); + method public double getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class DoubleAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAdder(); + method public void add(double); + method public double doubleValue(); + method public float floatValue(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public double sum(); + method public double sumThenReset(); + } + + public class LongAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAccumulator(java.util.function.LongBinaryOperator, long); + method public void accumulate(long); + method public double doubleValue(); + method public float floatValue(); + method public long get(); + method public long getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class LongAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAdder(); + method public void add(long); + method public void decrement(); + method public double doubleValue(); + method public float floatValue(); + method public void increment(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public long sum(); + method public long sumThenReset(); + } + + abstract class Striped64 extends java.lang.Number { + } + } package java.util.concurrent.locks { @@ -63365,6 +63705,34 @@ package java.util.concurrent.locks { method public void unlock(); } + public class StampedLock implements java.io.Serializable { + ctor public StampedLock(); + method public java.util.concurrent.locks.Lock asReadLock(); + method public java.util.concurrent.locks.ReadWriteLock asReadWriteLock(); + method public java.util.concurrent.locks.Lock asWriteLock(); + method public int getReadLockCount(); + method public boolean isReadLocked(); + method public boolean isWriteLocked(); + method public long readLock(); + method public long readLockInterruptibly() throws java.lang.InterruptedException; + method public long tryConvertToOptimisticRead(long); + method public long tryConvertToReadLock(long); + method public long tryConvertToWriteLock(long); + method public long tryOptimisticRead(); + method public long tryReadLock(); + method public long tryReadLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public boolean tryUnlockRead(); + method public boolean tryUnlockWrite(); + method public long tryWriteLock(); + method public long tryWriteLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public void unlock(long); + method public void unlockRead(long); + method public void unlockWrite(long); + method public boolean validate(long); + method public long writeLock(); + method public long writeLockInterruptibly() throws java.lang.InterruptedException; + } + } package java.util.function { diff --git a/api/test-current.txt b/api/test-current.txt index fcc03d9ab39b3..bfeeb9b59ea07 100644 --- a/api/test-current.txt +++ b/api/test-current.txt @@ -58344,18 +58344,28 @@ package java.util { public abstract interface Map { method public abstract void clear(); + method public default V compute(K, java.util.function.BiFunction); + method public default V computeIfAbsent(K, java.util.function.Function); + method public default V computeIfPresent(K, java.util.function.BiFunction); method public abstract boolean containsKey(java.lang.Object); method public abstract boolean containsValue(java.lang.Object); method public abstract java.util.Set> entrySet(); method public abstract boolean equals(java.lang.Object); method public default void forEach(java.util.function.BiConsumer); method public abstract V get(java.lang.Object); + method public default V getOrDefault(java.lang.Object, V); method public abstract int hashCode(); method public abstract boolean isEmpty(); method public abstract java.util.Set keySet(); + method public default V merge(K, V, java.util.function.BiFunction); method public abstract V put(K, V); method public abstract void putAll(java.util.Map); + method public default V putIfAbsent(K, V); method public abstract V remove(java.lang.Object); + method public default boolean remove(java.lang.Object, java.lang.Object); + method public default boolean replace(K, V, V); + method public default V replace(K, V); + method public default void replaceAll(java.util.function.BiFunction); method public abstract int size(); method public abstract java.util.Collection values(); } @@ -58363,6 +58373,8 @@ package java.util { public static abstract interface Map.Entry { method public static java.util.Comparator> comparingByKey(); method public static java.util.Comparator> comparingByKey(java.util.Comparator); + method public static java.util.Comparator> comparingByValue(); + method public static java.util.Comparator> comparingByValue(java.util.Comparator); method public abstract boolean equals(java.lang.Object); method public abstract K getKey(); method public abstract V getValue(); @@ -59144,6 +59156,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59207,6 +59220,78 @@ package java.util.concurrent { ctor public CancellationException(java.lang.String); } + public class CompletableFuture implements java.util.concurrent.CompletionStage java.util.concurrent.Future { + ctor public CompletableFuture(); + method public java.util.concurrent.CompletableFuture acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture allOf(java.util.concurrent.CompletableFuture...); + method public static java.util.concurrent.CompletableFuture anyOf(java.util.concurrent.CompletableFuture...); + method public java.util.concurrent.CompletableFuture applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public java.util.concurrent.CompletableFuture applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public boolean cancel(boolean); + method public boolean complete(T); + method public boolean completeExceptionally(java.lang.Throwable); + method public static java.util.concurrent.CompletableFuture completedFuture(U); + method public java.util.concurrent.CompletableFuture exceptionally(java.util.function.Function); + method public T get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; + method public T get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; + method public T getNow(T); + method public int getNumberOfDependents(); + method public java.util.concurrent.CompletableFuture handle(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public boolean isCancelled(); + method public boolean isCompletedExceptionally(); + method public boolean isDone(); + method public T join(); + method public void obtrudeException(java.lang.Throwable); + method public void obtrudeValue(T); + method public java.util.concurrent.CompletableFuture runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public java.util.concurrent.CompletableFuture runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable); + method public static java.util.concurrent.CompletableFuture runAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier); + method public static java.util.concurrent.CompletableFuture supplyAsync(java.util.function.Supplier, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAccept(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer); + method public java.util.concurrent.CompletableFuture thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenApply(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function); + method public java.util.concurrent.CompletableFuture thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public java.util.concurrent.CompletableFuture thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenCompose(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>); + method public java.util.concurrent.CompletableFuture thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture thenRun(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable); + method public java.util.concurrent.CompletableFuture thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public java.util.concurrent.CompletableFuture toCompletableFuture(); + method public java.util.concurrent.CompletableFuture whenComplete(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer); + method public java.util.concurrent.CompletableFuture whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + + public static abstract interface CompletableFuture.AsynchronousCompletionTask { + } + + public class CompletionException extends java.lang.RuntimeException { + ctor protected CompletionException(); + ctor protected CompletionException(java.lang.String); + ctor public CompletionException(java.lang.String, java.lang.Throwable); + ctor public CompletionException(java.lang.Throwable); + } + public abstract interface CompletionService { method public abstract java.util.concurrent.Future poll(); method public abstract java.util.concurrent.Future poll(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; @@ -59215,20 +59300,130 @@ package java.util.concurrent { method public abstract java.util.concurrent.Future take() throws java.lang.InterruptedException; } + public abstract interface CompletionStage { + method public abstract java.util.concurrent.CompletionStage acceptEither(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage acceptEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage applyToEither(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage applyToEitherAsync(java.util.concurrent.CompletionStage, java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage exceptionally(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage handle(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage handleAsync(java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterBoth(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterBothAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage runAfterEither(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage runAfterEitherAsync(java.util.concurrent.CompletionStage, java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAccept(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptAsync(java.util.function.Consumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenAcceptBoth(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage thenAcceptBothAsync(java.util.concurrent.CompletionStage, java.util.function.BiConsumer, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenApply(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function); + method public abstract java.util.concurrent.CompletionStage thenApplyAsync(java.util.function.Function, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCombine(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction); + method public abstract java.util.concurrent.CompletionStage thenCombineAsync(java.util.concurrent.CompletionStage, java.util.function.BiFunction, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenCompose(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>); + method public abstract java.util.concurrent.CompletionStage thenComposeAsync(java.util.function.Function>, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletionStage thenRun(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable); + method public abstract java.util.concurrent.CompletionStage thenRunAsync(java.lang.Runnable, java.util.concurrent.Executor); + method public abstract java.util.concurrent.CompletableFuture toCompletableFuture(); + method public abstract java.util.concurrent.CompletionStage whenComplete(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer); + method public abstract java.util.concurrent.CompletionStage whenCompleteAsync(java.util.function.BiConsumer, java.util.concurrent.Executor); + } + public class ConcurrentHashMap extends java.util.AbstractMap implements java.util.concurrent.ConcurrentMap java.io.Serializable { ctor public ConcurrentHashMap(); ctor public ConcurrentHashMap(int); ctor public ConcurrentHashMap(java.util.Map); ctor public ConcurrentHashMap(int, float); ctor public ConcurrentHashMap(int, float, int); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public boolean contains(java.lang.Object); method public java.util.Enumeration elements(); method public java.util.Set> entrySet(); + method public void forEach(java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiConsumer); + method public void forEach(long, java.util.function.BiFunction, java.util.function.Consumer); + method public void forEachEntry(long, java.util.function.Consumer>); + method public void forEachEntry(long, java.util.function.Function, ? extends U>, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Consumer); + method public void forEachKey(long, java.util.function.Function, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Consumer); + method public void forEachValue(long, java.util.function.Function, java.util.function.Consumer); + method public V getOrDefault(java.lang.Object, V); + method public java.util.concurrent.ConcurrentHashMap.KeySetView keySet(V); method public java.util.Enumeration keys(); + method public long mappingCount(); + method public V merge(K, V, java.util.function.BiFunction); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(); + method public static java.util.concurrent.ConcurrentHashMap.KeySetView newKeySet(int); method public V putIfAbsent(K, V); + method public U reduce(long, java.util.function.BiFunction, java.util.function.BiFunction); + method public java.util.Map.Entry reduceEntries(long, java.util.function.BiFunction, java.util.Map.Entry, ? extends java.util.Map.Entry>); + method public U reduceEntries(long, java.util.function.Function, ? extends U>, java.util.function.BiFunction); + method public double reduceEntriesToDouble(long, java.util.function.ToDoubleFunction>, double, java.util.function.DoubleBinaryOperator); + method public int reduceEntriesToInt(long, java.util.function.ToIntFunction>, int, java.util.function.IntBinaryOperator); + method public long reduceEntriesToLong(long, java.util.function.ToLongFunction>, long, java.util.function.LongBinaryOperator); + method public K reduceKeys(long, java.util.function.BiFunction); + method public U reduceKeys(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceKeysToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceKeysToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceKeysToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); + method public double reduceToDouble(long, java.util.function.ToDoubleBiFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceToInt(long, java.util.function.ToIntBiFunction, int, java.util.function.IntBinaryOperator); + method public long reduceToLong(long, java.util.function.ToLongBiFunction, long, java.util.function.LongBinaryOperator); + method public V reduceValues(long, java.util.function.BiFunction); + method public U reduceValues(long, java.util.function.Function, java.util.function.BiFunction); + method public double reduceValuesToDouble(long, java.util.function.ToDoubleFunction, double, java.util.function.DoubleBinaryOperator); + method public int reduceValuesToInt(long, java.util.function.ToIntFunction, int, java.util.function.IntBinaryOperator); + method public long reduceValuesToLong(long, java.util.function.ToLongFunction, long, java.util.function.LongBinaryOperator); method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); + method public U search(long, java.util.function.BiFunction); + method public U searchEntries(long, java.util.function.Function, ? extends U>); + method public U searchKeys(long, java.util.function.Function); + method public U searchValues(long, java.util.function.Function); + } + + static abstract class ConcurrentHashMap.CollectionView implements java.util.Collection java.io.Serializable { + method public final void clear(); + method public abstract boolean contains(java.lang.Object); + method public final boolean containsAll(java.util.Collection); + method public java.util.concurrent.ConcurrentHashMap getMap(); + method public final boolean isEmpty(); + method public abstract java.util.Iterator iterator(); + method public abstract boolean remove(java.lang.Object); + method public final boolean removeAll(java.util.Collection); + method public final boolean retainAll(java.util.Collection); + method public final int size(); + method public final java.lang.Object[] toArray(); + method public final T[] toArray(T[]); + method public final java.lang.String toString(); + } + + public static class ConcurrentHashMap.KeySetView extends java.util.concurrent.ConcurrentHashMap.CollectionView implements java.io.Serializable java.util.Set { + method public boolean add(K); + method public boolean addAll(java.util.Collection); + method public boolean contains(java.lang.Object); + method public void forEach(java.util.function.Consumer); + method public V getMappedValue(); + method public java.util.Iterator iterator(); + method public boolean remove(java.lang.Object); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedDeque extends java.util.AbstractCollection implements java.util.Deque java.io.Serializable { @@ -59258,6 +59453,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); } public class ConcurrentLinkedQueue extends java.util.AbstractQueue implements java.util.Queue java.io.Serializable { @@ -59268,6 +59464,7 @@ package java.util.concurrent { method public E peek(); method public E poll(); method public int size(); + method public java.util.Spliterator spliterator(); } public abstract interface ConcurrentMap implements java.util.Map { @@ -59299,6 +59496,9 @@ package java.util.concurrent { method public K ceilingKey(K); method public java.util.concurrent.ConcurrentSkipListMap clone(); method public java.util.Comparator comparator(); + method public V compute(K, java.util.function.BiFunction); + method public V computeIfAbsent(K, java.util.function.Function); + method public V computeIfPresent(K, java.util.function.BiFunction); method public java.util.NavigableSet descendingKeySet(); method public java.util.concurrent.ConcurrentNavigableMap descendingMap(); method public java.util.Set> entrySet(); @@ -59306,6 +59506,8 @@ package java.util.concurrent { method public K firstKey(); method public java.util.Map.Entry floorEntry(K); method public K floorKey(K); + method public void forEach(java.util.function.BiConsumer); + method public V getOrDefault(java.lang.Object, V); method public java.util.concurrent.ConcurrentNavigableMap headMap(K, boolean); method public java.util.concurrent.ConcurrentNavigableMap headMap(K); method public java.util.Map.Entry higherEntry(K); @@ -59314,6 +59516,7 @@ package java.util.concurrent { method public K lastKey(); method public java.util.Map.Entry lowerEntry(K); method public K lowerKey(K); + method public V merge(K, V, java.util.function.BiFunction); method public java.util.NavigableSet navigableKeySet(); method public java.util.Map.Entry pollFirstEntry(); method public java.util.Map.Entry pollLastEntry(); @@ -59321,6 +59524,7 @@ package java.util.concurrent { method public boolean remove(java.lang.Object, java.lang.Object); method public boolean replace(K, V, V); method public V replace(K, V); + method public void replaceAll(java.util.function.BiFunction); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, boolean, K, boolean); method public java.util.concurrent.ConcurrentNavigableMap subMap(K, K); method public java.util.concurrent.ConcurrentNavigableMap tailMap(K, boolean); @@ -59348,6 +59552,7 @@ package java.util.concurrent { method public E pollFirst(); method public E pollLast(); method public int size(); + method public java.util.Spliterator spliterator(); method public java.util.NavigableSet subSet(E, boolean, E, boolean); method public java.util.NavigableSet subSet(E, E); method public java.util.NavigableSet tailSet(E, boolean); @@ -59358,31 +59563,35 @@ package java.util.concurrent { ctor public CopyOnWriteArrayList(); ctor public CopyOnWriteArrayList(java.util.Collection); ctor public CopyOnWriteArrayList(E[]); - method public synchronized boolean add(E); - method public synchronized void add(int, E); - method public synchronized boolean addAll(java.util.Collection); - method public synchronized boolean addAll(int, java.util.Collection); - method public synchronized int addAllAbsent(java.util.Collection); - method public synchronized boolean addIfAbsent(E); - method public synchronized void clear(); + method public boolean add(E); + method public void add(int, E); + method public boolean addAll(java.util.Collection); + method public boolean addAll(int, java.util.Collection); + method public int addAllAbsent(java.util.Collection); + method public boolean addIfAbsent(E); + method public void clear(); method public java.lang.Object clone(); method public boolean contains(java.lang.Object); method public boolean containsAll(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public E get(int); - method public int indexOf(E, int); method public int indexOf(java.lang.Object); + method public int indexOf(E, int); method public boolean isEmpty(); method public java.util.Iterator iterator(); - method public int lastIndexOf(E, int); method public int lastIndexOf(java.lang.Object); - method public java.util.ListIterator listIterator(int); + method public int lastIndexOf(E, int); method public java.util.ListIterator listIterator(); - method public synchronized E remove(int); - method public synchronized boolean remove(java.lang.Object); - method public synchronized boolean removeAll(java.util.Collection); - method public synchronized boolean retainAll(java.util.Collection); - method public synchronized E set(int, E); + method public java.util.ListIterator listIterator(int); + method public E remove(int); + method public boolean remove(java.lang.Object); + method public boolean removeAll(java.util.Collection); + method public boolean removeIf(java.util.function.Predicate); + method public void replaceAll(java.util.function.UnaryOperator); + method public boolean retainAll(java.util.Collection); + method public E set(int, E); method public int size(); + method public void sort(java.util.Comparator); method public java.util.List subList(int, int); method public java.lang.Object[] toArray(); method public T[] toArray(T[]); @@ -59391,8 +59600,11 @@ package java.util.concurrent { public class CopyOnWriteArraySet extends java.util.AbstractSet implements java.io.Serializable { ctor public CopyOnWriteArraySet(); ctor public CopyOnWriteArraySet(java.util.Collection); + method public void forEach(java.util.function.Consumer); method public java.util.Iterator iterator(); + method public boolean removeIf(java.util.function.Predicate); method public int size(); + method public java.util.Spliterator spliterator(); } public class CountDownLatch { @@ -59403,6 +59615,32 @@ package java.util.concurrent { method public long getCount(); } + public abstract class CountedCompleter extends java.util.concurrent.ForkJoinTask { + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter, int); + ctor protected CountedCompleter(java.util.concurrent.CountedCompleter); + ctor protected CountedCompleter(); + method public final void addToPendingCount(int); + method public final boolean compareAndSetPendingCount(int, int); + method public void complete(T); + method public abstract void compute(); + method public final int decrementPendingCountUnlessZero(); + method protected final boolean exec(); + method public final java.util.concurrent.CountedCompleter firstComplete(); + method public final java.util.concurrent.CountedCompleter getCompleter(); + method public final int getPendingCount(); + method public T getRawResult(); + method public final java.util.concurrent.CountedCompleter getRoot(); + method public final void helpComplete(int); + method public final java.util.concurrent.CountedCompleter nextComplete(); + method public void onCompletion(java.util.concurrent.CountedCompleter); + method public boolean onExceptionalCompletion(java.lang.Throwable, java.util.concurrent.CountedCompleter); + method public final void propagateCompletion(); + method public final void quietlyCompleteRoot(); + method public final void setPendingCount(int); + method protected void setRawResult(T); + method public final void tryComplete(); + } + public class CyclicBarrier { ctor public CyclicBarrier(int, java.lang.Runnable); ctor public CyclicBarrier(int); @@ -59493,6 +59731,8 @@ package java.util.concurrent { method public static java.util.concurrent.ExecutorService newSingleThreadExecutor(java.util.concurrent.ThreadFactory); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(); method public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(int); + method public static java.util.concurrent.ExecutorService newWorkStealingPool(); method public static java.util.concurrent.Callable privilegedCallable(java.util.concurrent.Callable); method public static java.util.concurrent.Callable privilegedCallableUsingCurrentClassLoader(java.util.concurrent.Callable); method public static java.util.concurrent.ThreadFactory privilegedThreadFactory(); @@ -59506,11 +59746,13 @@ package java.util.concurrent { ctor public ForkJoinPool(int, java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory, java.lang.Thread.UncaughtExceptionHandler, boolean); method public boolean awaitQuiescence(long, java.util.concurrent.TimeUnit); method public boolean awaitTermination(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public static java.util.concurrent.ForkJoinPool commonPool(); method protected int drainTasksTo(java.util.Collection>); method public void execute(java.util.concurrent.ForkJoinTask); method public void execute(java.lang.Runnable); method public int getActiveThreadCount(); method public boolean getAsyncMode(); + method public static int getCommonPoolParallelism(); method public java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory getFactory(); method public int getParallelism(); method public int getPoolSize(); @@ -59548,6 +59790,7 @@ package java.util.concurrent { method public static java.util.concurrent.ForkJoinTask adapt(java.lang.Runnable, T); method public static java.util.concurrent.ForkJoinTask adapt(java.util.concurrent.Callable); method public boolean cancel(boolean); + method public final boolean compareAndSetForkJoinTaskTag(short, short); method public void complete(V); method public void completeExceptionally(java.lang.Throwable); method protected abstract boolean exec(); @@ -59555,6 +59798,7 @@ package java.util.concurrent { method public final V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException; method public final V get(long, java.util.concurrent.TimeUnit) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException, java.util.concurrent.TimeoutException; method public final java.lang.Throwable getException(); + method public final short getForkJoinTaskTag(); method public static java.util.concurrent.ForkJoinPool getPool(); method public static int getQueuedTaskCount(); method public abstract V getRawResult(); @@ -59573,9 +59817,11 @@ package java.util.concurrent { method protected static java.util.concurrent.ForkJoinTask peekNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollNextLocalTask(); method protected static java.util.concurrent.ForkJoinTask pollTask(); + method public final void quietlyComplete(); method public final void quietlyInvoke(); method public final void quietlyJoin(); method public void reinitialize(); + method public final short setForkJoinTaskTag(short); method protected abstract void setRawResult(V); method public boolean tryUnfork(); } @@ -59649,6 +59895,7 @@ package java.util.concurrent { method public E removeLast(); method public boolean removeLastOccurrence(java.lang.Object); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public E takeFirst() throws java.lang.InterruptedException; method public E takeLast() throws java.lang.InterruptedException; @@ -59669,6 +59916,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59688,6 +59936,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; method public void transfer(E) throws java.lang.InterruptedException; method public boolean tryTransfer(E); @@ -59735,6 +59984,7 @@ package java.util.concurrent { method public void put(E); method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59838,6 +60088,7 @@ package java.util.concurrent { method public void put(E) throws java.lang.InterruptedException; method public int remainingCapacity(); method public int size(); + method public java.util.Spliterator spliterator(); method public E take() throws java.lang.InterruptedException; } @@ -59967,112 +60218,136 @@ package java.util.concurrent.atomic { public class AtomicInteger extends java.lang.Number implements java.io.Serializable { ctor public AtomicInteger(int); ctor public AtomicInteger(); + method public final int accumulateAndGet(int, java.util.function.IntBinaryOperator); method public final int addAndGet(int); method public final boolean compareAndSet(int, int); method public final int decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final int get(); + method public final int getAndAccumulate(int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int); method public final int getAndDecrement(); method public final int getAndIncrement(); method public final int getAndSet(int); + method public final int getAndUpdate(java.util.function.IntUnaryOperator); method public final int incrementAndGet(); method public int intValue(); method public final void lazySet(int); method public long longValue(); method public final void set(int); + method public final int updateAndGet(java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int); } public class AtomicIntegerArray implements java.io.Serializable { ctor public AtomicIntegerArray(int); ctor public AtomicIntegerArray(int[]); + method public final int accumulateAndGet(int, int, java.util.function.IntBinaryOperator); method public final int addAndGet(int, int); method public final boolean compareAndSet(int, int, int); method public final int decrementAndGet(int); method public final int get(int); + method public final int getAndAccumulate(int, int, java.util.function.IntBinaryOperator); method public final int getAndAdd(int, int); method public final int getAndDecrement(int); method public final int getAndIncrement(int); method public final int getAndSet(int, int); + method public final int getAndUpdate(int, java.util.function.IntUnaryOperator); method public final int incrementAndGet(int); method public final void lazySet(int, int); method public final int length(); method public final void set(int, int); + method public final int updateAndGet(int, java.util.function.IntUnaryOperator); method public final boolean weakCompareAndSet(int, int, int); } public abstract class AtomicIntegerFieldUpdater { ctor protected AtomicIntegerFieldUpdater(); + method public final int accumulateAndGet(T, int, java.util.function.IntBinaryOperator); method public int addAndGet(T, int); method public abstract boolean compareAndSet(T, int, int); method public int decrementAndGet(T); method public abstract int get(T); + method public final int getAndAccumulate(T, int, java.util.function.IntBinaryOperator); method public int getAndAdd(T, int); method public int getAndDecrement(T); method public int getAndIncrement(T); method public int getAndSet(T, int); + method public final int getAndUpdate(T, java.util.function.IntUnaryOperator); method public int incrementAndGet(T); method public abstract void lazySet(T, int); method public static java.util.concurrent.atomic.AtomicIntegerFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, int); + method public final int updateAndGet(T, java.util.function.IntUnaryOperator); method public abstract boolean weakCompareAndSet(T, int, int); } public class AtomicLong extends java.lang.Number implements java.io.Serializable { ctor public AtomicLong(long); ctor public AtomicLong(); + method public final long accumulateAndGet(long, java.util.function.LongBinaryOperator); method public final long addAndGet(long); method public final boolean compareAndSet(long, long); method public final long decrementAndGet(); method public double doubleValue(); method public float floatValue(); method public final long get(); + method public final long getAndAccumulate(long, java.util.function.LongBinaryOperator); method public final long getAndAdd(long); method public final long getAndDecrement(); method public final long getAndIncrement(); method public final long getAndSet(long); + method public final long getAndUpdate(java.util.function.LongUnaryOperator); method public final long incrementAndGet(); method public int intValue(); method public final void lazySet(long); method public long longValue(); method public final void set(long); + method public final long updateAndGet(java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(long, long); } public class AtomicLongArray implements java.io.Serializable { ctor public AtomicLongArray(int); ctor public AtomicLongArray(long[]); + method public final long accumulateAndGet(int, long, java.util.function.LongBinaryOperator); method public long addAndGet(int, long); method public final boolean compareAndSet(int, long, long); method public final long decrementAndGet(int); method public final long get(int); + method public final long getAndAccumulate(int, long, java.util.function.LongBinaryOperator); method public final long getAndAdd(int, long); method public final long getAndDecrement(int); method public final long getAndIncrement(int); method public final long getAndSet(int, long); + method public final long getAndUpdate(int, java.util.function.LongUnaryOperator); method public final long incrementAndGet(int); method public final void lazySet(int, long); method public final int length(); method public final void set(int, long); + method public final long updateAndGet(int, java.util.function.LongUnaryOperator); method public final boolean weakCompareAndSet(int, long, long); } public abstract class AtomicLongFieldUpdater { ctor protected AtomicLongFieldUpdater(); + method public final long accumulateAndGet(T, long, java.util.function.LongBinaryOperator); method public long addAndGet(T, long); method public abstract boolean compareAndSet(T, long, long); method public long decrementAndGet(T); method public abstract long get(T); + method public final long getAndAccumulate(T, long, java.util.function.LongBinaryOperator); method public long getAndAdd(T, long); method public long getAndDecrement(T); method public long getAndIncrement(T); method public long getAndSet(T, long); + method public final long getAndUpdate(T, java.util.function.LongUnaryOperator); method public long incrementAndGet(T); method public abstract void lazySet(T, long); method public static java.util.concurrent.atomic.AtomicLongFieldUpdater newUpdater(java.lang.Class, java.lang.String); method public abstract void set(T, long); + method public final long updateAndGet(T, java.util.function.LongUnaryOperator); method public abstract boolean weakCompareAndSet(T, long, long); } @@ -60090,34 +60365,46 @@ package java.util.concurrent.atomic { public class AtomicReference implements java.io.Serializable { ctor public AtomicReference(V); ctor public AtomicReference(); + method public final V accumulateAndGet(V, java.util.function.BinaryOperator); method public final boolean compareAndSet(V, V); method public final V get(); + method public final V getAndAccumulate(V, java.util.function.BinaryOperator); method public final V getAndSet(V); + method public final V getAndUpdate(java.util.function.UnaryOperator); method public final void lazySet(V); method public final void set(V); + method public final V updateAndGet(java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(V, V); } public class AtomicReferenceArray implements java.io.Serializable { ctor public AtomicReferenceArray(int); ctor public AtomicReferenceArray(E[]); + method public final E accumulateAndGet(int, E, java.util.function.BinaryOperator); method public final boolean compareAndSet(int, E, E); method public final E get(int); + method public final E getAndAccumulate(int, E, java.util.function.BinaryOperator); method public final E getAndSet(int, E); + method public final E getAndUpdate(int, java.util.function.UnaryOperator); method public final void lazySet(int, E); method public final int length(); method public final void set(int, E); + method public final E updateAndGet(int, java.util.function.UnaryOperator); method public final boolean weakCompareAndSet(int, E, E); } public abstract class AtomicReferenceFieldUpdater { ctor protected AtomicReferenceFieldUpdater(); + method public final V accumulateAndGet(T, V, java.util.function.BinaryOperator); method public abstract boolean compareAndSet(T, V, V); method public abstract V get(T); + method public final V getAndAccumulate(T, V, java.util.function.BinaryOperator); method public V getAndSet(T, V); + method public final V getAndUpdate(T, java.util.function.UnaryOperator); method public abstract void lazySet(T, V); method public static java.util.concurrent.atomic.AtomicReferenceFieldUpdater newUpdater(java.lang.Class, java.lang.Class, java.lang.String); method public abstract void set(T, V); + method public final V updateAndGet(T, java.util.function.UnaryOperator); method public abstract boolean weakCompareAndSet(T, V, V); } @@ -60132,6 +60419,59 @@ package java.util.concurrent.atomic { method public boolean weakCompareAndSet(V, V, int, int); } + public class DoubleAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAccumulator(java.util.function.DoubleBinaryOperator, double); + method public void accumulate(double); + method public double doubleValue(); + method public float floatValue(); + method public double get(); + method public double getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class DoubleAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public DoubleAdder(); + method public void add(double); + method public double doubleValue(); + method public float floatValue(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public double sum(); + method public double sumThenReset(); + } + + public class LongAccumulator extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAccumulator(java.util.function.LongBinaryOperator, long); + method public void accumulate(long); + method public double doubleValue(); + method public float floatValue(); + method public long get(); + method public long getThenReset(); + method public int intValue(); + method public long longValue(); + method public void reset(); + } + + public class LongAdder extends java.util.concurrent.atomic.Striped64 implements java.io.Serializable { + ctor public LongAdder(); + method public void add(long); + method public void decrement(); + method public double doubleValue(); + method public float floatValue(); + method public void increment(); + method public int intValue(); + method public long longValue(); + method public void reset(); + method public long sum(); + method public long sumThenReset(); + } + + abstract class Striped64 extends java.lang.Number { + } + } package java.util.concurrent.locks { @@ -60339,6 +60679,34 @@ package java.util.concurrent.locks { method public void unlock(); } + public class StampedLock implements java.io.Serializable { + ctor public StampedLock(); + method public java.util.concurrent.locks.Lock asReadLock(); + method public java.util.concurrent.locks.ReadWriteLock asReadWriteLock(); + method public java.util.concurrent.locks.Lock asWriteLock(); + method public int getReadLockCount(); + method public boolean isReadLocked(); + method public boolean isWriteLocked(); + method public long readLock(); + method public long readLockInterruptibly() throws java.lang.InterruptedException; + method public long tryConvertToOptimisticRead(long); + method public long tryConvertToReadLock(long); + method public long tryConvertToWriteLock(long); + method public long tryOptimisticRead(); + method public long tryReadLock(); + method public long tryReadLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public boolean tryUnlockRead(); + method public boolean tryUnlockWrite(); + method public long tryWriteLock(); + method public long tryWriteLock(long, java.util.concurrent.TimeUnit) throws java.lang.InterruptedException; + method public void unlock(long); + method public void unlockRead(long); + method public void unlockWrite(long); + method public boolean validate(long); + method public long writeLock(); + method public long writeLockInterruptibly() throws java.lang.InterruptedException; + } + } package java.util.function {