712 |
|
} |
713 |
|
|
714 |
|
/** |
715 |
< |
* Return the TreeNode (or null if not found) for the given key |
715 |
> |
* Returns the TreeNode (or null if not found) for the given key |
716 |
|
* starting at given root. |
717 |
|
*/ |
718 |
|
@SuppressWarnings("unchecked") // suppress Comparable cast warning |
2327 |
|
} |
2328 |
|
|
2329 |
|
public final void remove() { |
2330 |
< |
if (nextVal == null) |
2330 |
> |
if (nextVal == null && last == null) |
2331 |
|
advance(); |
2332 |
|
Node e = last; |
2333 |
|
if (e == null) |
2657 |
|
* |
2658 |
|
* @param key key with which the specified value is to be associated |
2659 |
|
* @param remappingFunction the function to compute a value |
2660 |
< |
* @return the new value associated with |
2661 |
< |
* the specified key, or null if none. |
2660 |
> |
* @return the new value associated with the specified key, or null if none |
2661 |
|
* @throws NullPointerException if the specified key or remappingFunction |
2662 |
|
* is null |
2663 |
|
* @throws IllegalStateException if the computation detectably |
2703 |
|
* |
2704 |
|
* @param key key with which the specified value is to be associated |
2705 |
|
* @param remappingFunction the function to compute a value |
2706 |
< |
* @return the new value associated with |
2708 |
< |
* the specified key, or null if none. |
2706 |
> |
* @return the new value associated with the specified key, or null if none |
2707 |
|
* @throws NullPointerException if the specified key or remappingFunction |
2708 |
|
* is null |
2709 |
|
* @throws IllegalStateException if the computation detectably |
2896 |
|
} |
2897 |
|
|
2898 |
|
/** |
2899 |
< |
* Returns a partionable iterator of the keys in this map. |
2899 |
> |
* Returns a partitionable iterator of the keys in this map. |
2900 |
|
* |
2901 |
< |
* @return a partionable iterator of the keys in this map |
2901 |
> |
* @return a partitionable iterator of the keys in this map |
2902 |
|
*/ |
2903 |
|
public Spliterator<K> keySpliterator() { |
2904 |
|
return new KeyIterator<K,V>(this); |
2905 |
|
} |
2906 |
|
|
2907 |
|
/** |
2908 |
< |
* Returns a partionable iterator of the values in this map. |
2908 |
> |
* Returns a partitionable iterator of the values in this map. |
2909 |
|
* |
2910 |
< |
* @return a partionable iterator of the values in this map |
2910 |
> |
* @return a partitionable iterator of the values in this map |
2911 |
|
*/ |
2912 |
|
public Spliterator<V> valueSpliterator() { |
2913 |
|
return new ValueIterator<K,V>(this); |
2914 |
|
} |
2915 |
|
|
2916 |
|
/** |
2917 |
< |
* Returns a partionable iterator of the entries in this map. |
2917 |
> |
* Returns a partitionable iterator of the entries in this map. |
2918 |
|
* |
2919 |
< |
* @return a partionable iterator of the entries in this map |
2919 |
> |
* @return a partitionable iterator of the entries in this map |
2920 |
|
*/ |
2921 |
|
public Spliterator<Map.Entry<K,V>> entrySpliterator() { |
2922 |
|
return new EntryIterator<K,V>(this); |
3516 |
|
|
3517 |
|
/** |
3518 |
|
* An extended view of a ConcurrentHashMap supporting bulk |
3519 |
< |
* parallel operations. These operations are designed to be be |
3519 |
> |
* parallel operations. These operations are designed to be |
3520 |
|
* safely, and often sensibly, applied even with maps that are |
3521 |
|
* being concurrently updated by other threads; for example, when |
3522 |
|
* computing a snapshot summary of the values in a shared |
3634 |
|
* |
3635 |
|
* @param action the action |
3636 |
|
*/ |
3637 |
< |
public void forEach(BiAction<K,V> action) { |
3637 |
> |
public void forEach(BiAction<K,V> action) { |
3638 |
|
fjp.invoke(ForkJoinTasks.forEach |
3639 |
|
(ConcurrentHashMapV8.this, action)); |
3640 |
|
} |
3648 |
|
* which case the action is not applied). |
3649 |
|
* @param action the action |
3650 |
|
*/ |
3651 |
< |
public <U> void forEach(BiFun<? super K, ? super V, ? extends U> transformer, |
3651 |
> |
public <U> void forEach(BiFun<? super K, ? super V, ? extends U> transformer, |
3652 |
|
Action<U> action) { |
3653 |
|
fjp.invoke(ForkJoinTasks.forEach |
3654 |
|
(ConcurrentHashMapV8.this, transformer, action)); |
3748 |
|
} |
3749 |
|
|
3750 |
|
/** |
3751 |
< |
* Performs the given action for each key |
3751 |
> |
* Performs the given action for each key. |
3752 |
|
* |
3753 |
|
* @param action the action |
3754 |
|
*/ |
3755 |
< |
public void forEachKey(Action<K> action) { |
3755 |
> |
public void forEachKey(Action<K> action) { |
3756 |
|
fjp.invoke(ForkJoinTasks.forEachKey |
3757 |
|
(ConcurrentHashMapV8.this, action)); |
3758 |
|
} |
3759 |
|
|
3760 |
|
/** |
3761 |
|
* Performs the given action for each non-null transformation |
3762 |
< |
* of each key |
3762 |
> |
* of each key. |
3763 |
|
* |
3764 |
|
* @param transformer a function returning the transformation |
3765 |
|
* for an element, or null of there is no transformation (in |
3766 |
|
* which case the action is not applied). |
3767 |
|
* @param action the action |
3768 |
|
*/ |
3769 |
< |
public <U> void forEachKey(Fun<? super K, ? extends U> transformer, |
3769 |
> |
public <U> void forEachKey(Fun<? super K, ? extends U> transformer, |
3770 |
|
Action<U> action) { |
3771 |
|
fjp.invoke(ForkJoinTasks.forEachKey |
3772 |
|
(ConcurrentHashMapV8.this, transformer, action)); |
3878 |
|
} |
3879 |
|
|
3880 |
|
/** |
3881 |
< |
* Performs the given action for each value |
3881 |
> |
* Performs the given action for each value. |
3882 |
|
* |
3883 |
|
* @param action the action |
3884 |
|
*/ |
3885 |
< |
public void forEachValue(Action<V> action) { |
3885 |
> |
public void forEachValue(Action<V> action) { |
3886 |
|
fjp.invoke(ForkJoinTasks.forEachValue |
3887 |
|
(ConcurrentHashMapV8.this, action)); |
3888 |
|
} |
3889 |
|
|
3890 |
|
/** |
3891 |
|
* Performs the given action for each non-null transformation |
3892 |
< |
* of each value |
3892 |
> |
* of each value. |
3893 |
|
* |
3894 |
|
* @param transformer a function returning the transformation |
3895 |
|
* for an element, or null of there is no transformation (in |
3896 |
|
* which case the action is not applied). |
3897 |
|
*/ |
3898 |
< |
public <U> void forEachValue(Fun<? super V, ? extends U> transformer, |
3898 |
> |
public <U> void forEachValue(Fun<? super V, ? extends U> transformer, |
3899 |
|
Action<U> action) { |
3900 |
|
fjp.invoke(ForkJoinTasks.forEachValue |
3901 |
|
(ConcurrentHashMapV8.this, transformer, action)); |
4007 |
|
} |
4008 |
|
|
4009 |
|
/** |
4010 |
< |
* Perform the given action for each entry |
4010 |
> |
* Performs the given action for each entry. |
4011 |
|
* |
4012 |
|
* @param action the action |
4013 |
|
*/ |
4014 |
< |
public void forEachEntry(Action<Map.Entry<K,V>> action) { |
4014 |
> |
public void forEachEntry(Action<Map.Entry<K,V>> action) { |
4015 |
|
fjp.invoke(ForkJoinTasks.forEachEntry |
4016 |
|
(ConcurrentHashMapV8.this, action)); |
4017 |
|
} |
4018 |
|
|
4019 |
|
/** |
4020 |
< |
* Perform the given action for each non-null transformation |
4021 |
< |
* of each entry |
4020 |
> |
* Performs the given action for each non-null transformation |
4021 |
> |
* of each entry. |
4022 |
|
* |
4023 |
|
* @param transformer a function returning the transformation |
4024 |
|
* for an element, or null of there is no transformation (in |
4025 |
|
* which case the action is not applied). |
4026 |
|
* @param action the action |
4027 |
|
*/ |
4028 |
< |
public <U> void forEachEntry(Fun<Map.Entry<K,V>, ? extends U> transformer, |
4028 |
> |
public <U> void forEachEntry(Fun<Map.Entry<K,V>, ? extends U> transformer, |
4029 |
|
Action<U> action) { |
4030 |
|
fjp.invoke(ForkJoinTasks.forEachEntry |
4031 |
|
(ConcurrentHashMapV8.this, transformer, action)); |
4157 |
|
* @param action the action |
4158 |
|
* @return the task |
4159 |
|
*/ |
4160 |
< |
public static <K,V> ForkJoinTask<Void> forEach |
4160 |
> |
public static <K,V> ForkJoinTask<Void> forEach |
4161 |
|
(ConcurrentHashMapV8<K,V> map, |
4162 |
|
BiAction<K,V> action) { |
4163 |
|
if (action == null) throw new NullPointerException(); |
4175 |
|
* @param action the action |
4176 |
|
* @return the task |
4177 |
|
*/ |
4178 |
< |
public static <K,V,U> ForkJoinTask<Void> forEach |
4178 |
> |
public static <K,V,U> ForkJoinTask<Void> forEach |
4179 |
|
(ConcurrentHashMapV8<K,V> map, |
4180 |
|
BiFun<? super K, ? super V, ? extends U> transformer, |
4181 |
|
Action<U> action) { |
4302 |
|
|
4303 |
|
/** |
4304 |
|
* Returns a task that when invoked, performs the given action |
4305 |
< |
* for each key |
4305 |
> |
* for each key. |
4306 |
|
* |
4307 |
|
* @param map the map |
4308 |
|
* @param action the action |
4309 |
|
* @return the task |
4310 |
|
*/ |
4311 |
< |
public static <K,V> ForkJoinTask<Void> forEachKey |
4311 |
> |
public static <K,V> ForkJoinTask<Void> forEachKey |
4312 |
|
(ConcurrentHashMapV8<K,V> map, |
4313 |
|
Action<K> action) { |
4314 |
|
if (action == null) throw new NullPointerException(); |
4317 |
|
|
4318 |
|
/** |
4319 |
|
* Returns a task that when invoked, performs the given action |
4320 |
< |
* for each non-null transformation of each key |
4320 |
> |
* for each non-null transformation of each key. |
4321 |
|
* |
4322 |
|
* @param map the map |
4323 |
|
* @param transformer a function returning the transformation |
4326 |
|
* @param action the action |
4327 |
|
* @return the task |
4328 |
|
*/ |
4329 |
< |
public static <K,V,U> ForkJoinTask<Void> forEachKey |
4329 |
> |
public static <K,V,U> ForkJoinTask<Void> forEachKey |
4330 |
|
(ConcurrentHashMapV8<K,V> map, |
4331 |
|
Fun<? super K, ? extends U> transformer, |
4332 |
|
Action<U> action) { |
4470 |
|
|
4471 |
|
/** |
4472 |
|
* Returns a task that when invoked, performs the given action |
4473 |
< |
* for each value |
4473 |
> |
* for each value. |
4474 |
|
* |
4475 |
|
* @param map the map |
4476 |
|
* @param action the action |
4477 |
|
*/ |
4478 |
< |
public static <K,V> ForkJoinTask<Void> forEachValue |
4478 |
> |
public static <K,V> ForkJoinTask<Void> forEachValue |
4479 |
|
(ConcurrentHashMapV8<K,V> map, |
4480 |
|
Action<V> action) { |
4481 |
|
if (action == null) throw new NullPointerException(); |
4484 |
|
|
4485 |
|
/** |
4486 |
|
* Returns a task that when invoked, performs the given action |
4487 |
< |
* for each non-null transformation of each value |
4487 |
> |
* for each non-null transformation of each value. |
4488 |
|
* |
4489 |
|
* @param map the map |
4490 |
|
* @param transformer a function returning the transformation |
4492 |
|
* which case the action is not applied). |
4493 |
|
* @param action the action |
4494 |
|
*/ |
4495 |
< |
public static <K,V,U> ForkJoinTask<Void> forEachValue |
4495 |
> |
public static <K,V,U> ForkJoinTask<Void> forEachValue |
4496 |
|
(ConcurrentHashMapV8<K,V> map, |
4497 |
|
Fun<? super V, ? extends U> transformer, |
4498 |
|
Action<U> action) { |
4638 |
|
|
4639 |
|
/** |
4640 |
|
* Returns a task that when invoked, perform the given action |
4641 |
< |
* for each entry |
4641 |
> |
* for each entry. |
4642 |
|
* |
4643 |
|
* @param map the map |
4644 |
|
* @param action the action |
4645 |
|
*/ |
4646 |
< |
public static <K,V> ForkJoinTask<Void> forEachEntry |
4646 |
> |
public static <K,V> ForkJoinTask<Void> forEachEntry |
4647 |
|
(ConcurrentHashMapV8<K,V> map, |
4648 |
|
Action<Map.Entry<K,V>> action) { |
4649 |
|
if (action == null) throw new NullPointerException(); |
4652 |
|
|
4653 |
|
/** |
4654 |
|
* Returns a task that when invoked, perform the given action |
4655 |
< |
* for each non-null transformation of each entry |
4655 |
> |
* for each non-null transformation of each entry. |
4656 |
|
* |
4657 |
|
* @param map the map |
4658 |
|
* @param transformer a function returning the transformation |
4660 |
|
* which case the action is not applied). |
4661 |
|
* @param action the action |
4662 |
|
*/ |
4663 |
< |
public static <K,V,U> ForkJoinTask<Void> forEachEntry |
4663 |
> |
public static <K,V,U> ForkJoinTask<Void> forEachEntry |
4664 |
|
(ConcurrentHashMapV8<K,V> map, |
4665 |
|
Fun<Map.Entry<K,V>, ? extends U> transformer, |
4666 |
|
Action<U> action) { |
4809 |
|
|
4810 |
|
/** |
4811 |
|
* Base for FJ tasks for bulk operations. This adds a variant of |
4812 |
< |
* CountedCompleters and some split and merge bookeeping to |
4812 |
> |
* CountedCompleters and some split and merge bookkeeping to |
4813 |
|
* iterator functionality. The forEach and reduce methods are |
4814 |
|
* similar to those illustrated in CountedCompleter documentation, |
4815 |
|
* except that bottom-up reduction completions perform them within |
4840 |
|
// FJ methods |
4841 |
|
|
4842 |
|
/** |
4843 |
< |
* Propagate completion. Note that all reduce actions |
4843 |
> |
* Propagates completion. Note that all reduce actions |
4844 |
|
* bypass this method to combine while completing. |
4845 |
|
*/ |
4846 |
|
final void tryComplete() { |
4858 |
|
} |
4859 |
|
|
4860 |
|
/** |
4861 |
< |
* Force root task to throw exception unless already complete. |
4861 |
> |
* Forces root task to throw exception unless already complete. |
4862 |
|
*/ |
4863 |
|
final void tryAbortComputation(Throwable ex) { |
4864 |
|
for (BulkTask<K,V,?> a = this;;) { |
4875 |
|
try { |
4876 |
|
compute(); |
4877 |
|
} |
4878 |
< |
catch(Throwable ex) { |
4878 |
> |
catch (Throwable ex) { |
4879 |
|
tryAbortComputation(ex); |
4880 |
|
} |
4881 |
|
return false; |
4891 |
|
} |
4892 |
|
|
4893 |
|
/** |
4894 |
< |
* Return approx exp2 of the number of times (minus one) to |
4894 |
> |
* Returns approx exp2 of the number of times (minus one) to |
4895 |
|
* split task by two before executing leaf action. This value |
4896 |
|
* is faster to compute and more convenient to use as a guide |
4897 |
|
* to splitting than is the depth, since it is used while |
4902 |
|
if (b < 0) { |
4903 |
|
long n = map.counter.sum(); |
4904 |
|
int sp = getPool().getParallelism() << 3; // slack of 8 |
4905 |
< |
b = batch = (n <= 0L)? 0 : (n < (long)sp) ? (int)n : sp; |
4905 |
> |
b = batch = (n <= 0L) ? 0 : (n < (long)sp) ? (int)n : sp; |
4906 |
|
} |
4907 |
|
return b; |
4908 |
|
} |
4914 |
|
"Unexpected null function"; |
4915 |
|
|
4916 |
|
/** |
4917 |
< |
* Return exportable snapshot entry |
4917 |
> |
* Returns exportable snapshot entry. |
4918 |
|
*/ |
4919 |
|
static <K,V> AbstractMap.SimpleEntry<K,V> entryFor(K k, V v) { |
4920 |
|
return new AbstractMap.SimpleEntry(k, v); |