Skip to content

Commit f800b30

Browse files
pkamath2akarnokd
authored andcommitted
Javadoc updates for RXJava Issue 6289 (#6308)
* Javadoc updates for RXJava Issue 6289 * With review comments on issue 6289
1 parent e82b82e commit f800b30

File tree

1 file changed

+47
-0
lines changed

1 file changed

+47
-0
lines changed

src/main/java/io/reactivex/Flowable.java

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10345,6 +10345,14 @@ public final Disposable forEachWhile(final Predicate<? super T> onNext, final Co
1034510345
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1034610346
* {@code GroupedPublisher}s that do not concern you. Instead, you can signal to them that they may
1034710347
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10348+
* <p>
10349+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10350+
* the unconsumed groups may starve other groups due to the internal backpressure
10351+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10352+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10353+
* value to be greater or equal to the expected number of groups, possibly using
10354+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
10355+
*
1034810356
* <dl>
1034910357
* <dt><b>Backpressure:</b></dt>
1035010358
* <dd>Both the returned and its inner {@code Publisher}s honor backpressure and the source {@code Publisher}
@@ -10385,6 +10393,13 @@ public final <K> Flowable<GroupedFlowable<K, T>> groupBy(Function<? super T, ? e
1038510393
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1038610394
* {@code GroupedPublisher}s that do not concern you. Instead, you can signal to them that they may
1038710395
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10396+
* <p>
10397+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10398+
* the unconsumed groups may starve other groups due to the internal backpressure
10399+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10400+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10401+
* value to be greater or equal to the expected number of groups, possibly using
10402+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
1038810403
* <dl>
1038910404
* <dt><b>Backpressure:</b></dt>
1039010405
* <dd>Both the returned and its inner {@code Publisher}s honor backpressure and the source {@code Publisher}
@@ -10428,6 +10443,14 @@ public final <K> Flowable<GroupedFlowable<K, T>> groupBy(Function<? super T, ? e
1042810443
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1042910444
* {@code GroupedPublisher}s that do not concern you. Instead, you can signal to them that they may
1043010445
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10446+
* <p>
10447+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10448+
* the unconsumed groups may starve other groups due to the internal backpressure
10449+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10450+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10451+
* value to be greater or equal to the expected number of groups, possibly using
10452+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
10453+
*
1043110454
* <dl>
1043210455
* <dt><b>Backpressure:</b></dt>
1043310456
* <dd>Both the returned and its inner {@code Publisher}s honor backpressure and the source {@code Publisher}
@@ -10473,6 +10496,14 @@ public final <K, V> Flowable<GroupedFlowable<K, V>> groupBy(Function<? super T,
1047310496
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1047410497
* {@code GroupedPublisher}s that do not concern you. Instead, you can signal to them that they may
1047510498
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10499+
* <p>
10500+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10501+
* the unconsumed groups may starve other groups due to the internal backpressure
10502+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10503+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10504+
* value to be greater or equal to the expected number of groups, possibly using
10505+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
10506+
*
1047610507
* <dl>
1047710508
* <dt><b>Backpressure:</b></dt>
1047810509
* <dd>Both the returned and its inner {@code Publisher}s honor backpressure and the source {@code Publisher}
@@ -10521,6 +10552,14 @@ public final <K, V> Flowable<GroupedFlowable<K, V>> groupBy(Function<? super T,
1052110552
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1052210553
* {@code GroupedPublisher}s that do not concern you. Instead, you can signal to them that they may
1052310554
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10555+
* <p>
10556+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10557+
* the unconsumed groups may starve other groups due to the internal backpressure
10558+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10559+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10560+
* value to be greater or equal to the expected number of groups, possibly using
10561+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
10562+
*
1052410563
* <dl>
1052510564
* <dt><b>Backpressure:</b></dt>
1052610565
* <dd>Both the returned and its inner {@code Publisher}s honor backpressure and the source {@code Publisher}
@@ -10617,6 +10656,14 @@ public final <K, V> Flowable<GroupedFlowable<K, V>> groupBy(Function<? super T,
1061710656
* is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
1061810657
* {@code GroupedFlowable}s that do not concern you. Instead, you can signal to them that they may
1061910658
* discard their buffers by applying an operator like {@link #ignoreElements} to them.
10659+
* <p>
10660+
* Note that the {@link GroupedFlowable}s should be subscribed to as soon as possible, otherwise,
10661+
* the unconsumed groups may starve other groups due to the internal backpressure
10662+
* coordination of the {@code groupBy} operator. Such hangs can be usually avoided by using
10663+
* {@link #flatMap(Function, int)} or {@link #concatMapEager(Function, int, int)} and overriding the default maximum concurrency
10664+
* value to be greater or equal to the expected number of groups, possibly using
10665+
* {@code Integer.MAX_VALUE} if the number of expected groups is unknown.
10666+
*
1062010667
* <dl>
1062110668
* <dt><b>Backpressure:</b></dt>
1062210669
* <dd>Both the returned and its inner {@code GroupedFlowable}s honor backpressure and the source {@code Publisher}

0 commit comments

Comments
 (0)