v3.1.0.M1

This is the MILESTONE 1 release of Reactor 3.1.0, which will be part of the Bismuth Release Train.

This MILESTONE covers API changes of the upcoming 3.1.0 release, as well as a few improvements.
Most API changes have been introduced using a deprecate-and-offer-alternative strategy in the latest releases in the 3.0.x branch.
However, please have a look at the section below for update considerations if you haven't progressively updated each new 3.0.x.

⚠️ Update considerations and API changes

• From a general perspective, most deprecated elements in 3.0.x have now been removed (#323)
• ⚠️ Mono.then(Function) and Mono.flatMap(): how to migrate (#516):
  • first replace all usage of Mono.flatMap with flatMapMany
  • then replace all usage of Mono.then(Function) (which has been removed) with flatMap.
  • the gist of this change is that the old flatMap was actually changing the return type to Flux and was thus missing the "Many" suffix we usually use. At the same time, then(Function) was transforming the source value (unlike any other form of then which usually just ignore the emissions and act on the onComplete). Thus it was actually more of a flatMap.
• error handling operators have been made more consistent between Mono and Flux (#533, #535, #531)
  • Flux: onErrorResumeWith -> onErrorResume, mapError -> onErrorMap, switchOnError -> replace with onErrorResume with a lambda that ignores the left hand side.
  • Mono: otherwise -> onErrorResume, otherwiseReturn -> onErrorReturn, otherwiseIfEmpty -> switchIfEmpty, mapError -> onErrorMap
• buffer operators that take a (Publisher, Function) as arguments (open boundary and closing selector) have been renamed to bufferWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)
• delay in Flux is removed in favor of Flux.delayElements (see #263)
• doAfterTerminate doesn't cause an onError signal if its callback fails (#270)
• then:
  • variants of then that took a Supplier have been removed. Use defer if you really need to provide the continuation Mono lazily (#547)
  • Flux.then(Publisher<Void>) has been removed in favor of thenEmpty
  • Mono.then(Function) is now Mono.flatMap (see 1st entry)
• window:
  • various window operators have been aligned in behavior with respect to cancellation (#384)
  • window operators that take a (Publisher, Function) as arguments (open boundary and closing selector) have been renamed to windowWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)
  • Flux.window() has been removed in favor of window(Publisher), windowUntil and windowWhile(see #260)
• zip(Iterable) in Flux has been removed as it was by nature unusable (#338)
• Cross operator changes based on prefix / parameter pattern:
  • xxxMillis: Timed operators with the Millis suffix have been removed, use their Duration based counterparts
  • xxx(boolean delayError): All operators that were taking a delayError boolean parameter instead of having a DelayError suffixed variant now use the suffix variant pattern (see #480)
  • xxx(Function<Throwable, ?>): Operators dealing with a Predicate or Function of Throwable have been aligned to take a more generic <? super Throwable>
  • All subscribe methods in Flux that had a prefetch parameter have been removed (you can use limitRate to achieve the same effect)
• Removal of interfaces and classes:
  • Old introspection interfaces, which were mostly only used internally, have been removed in favor of the single Scannable interface (Loopback, MultiProducer, MultiReceiver, Producer, Receiver, Trackable, see #249, 20bd64d)
  • Cancellation has been removed and replaced with Disposable (see #322, 844769d)
  • TimedScheduler has been removed, as well as the Scheduler#shutdown method (all schedulers are now time capable and you can use dispose(). Note that most timed operators now use the parallel() Scheduler by default. see #451, #322)
• Processors have been reworked. Notably you cannot connect explicitly anymore but should rather use the sink() method. For details and rationale, see #525.
• Some changes have been made to Operators support class for writing custom operators:
  • Operators.SubscriberAdapter is not part of the public API anymore.
  • Operators.addAndGet(AtomicLong, ...) has been removed in favor of the AtomicLongFieldUpdater alternative.

✨ New features and improvements

• Added a Flux.then(Mono) operator to align with the Mono equivalent (#547)
• Added Mono.delayUntil and Mono.delayUntilOther to delay the emission of a Mono until after a companion Publisher completes (which can be generated from the source value in the case of delayUntil). This is very close to untilOther except it acts on onComplete. (#558, #568)
• The error message in case some operators badly behave with backpressure ("Queue full?!") has been made more explicit (#540)
• ParallelSubscriber now has a subscribe() method and all subscribe(...) methods are final like in Flux (#564)

🪲 Bug fixes

• Mono.untilOther would not return a new instance when chained with itself (#515)
• Operators#setOnce was cancelling the wrong subscription

📖 Documentation, Tests and Build

• The javadoc has been reviewed and polished across the board. Most notably, a full review of Flux and Mono javadoc has been made. It also now outputs UTF-8 html, and a few marble diagrams were added (#545, #559, #528, #513, #544)
• the reference documentation has been updated to keep up with new/modified operators (#516, #535, #555)

👍 Thanks to the following contributors that also participated to this release

@rajinisivaram, @sdeleuze, @schauder, @Dmitriusan, @garyrussell

v3.0.7.RELEASE

This is the 7th release of Reactor 3.0, part of Aluminium Release Train.

It contains backports of bug fixes and API deprecations from the 3.1.0 branch,
the later allowing to lay an easier migration path ahead of time when possible.
This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• Mono.flatMap becomes flatMapMany. In turn in 3.1.0 flatMap will change to the signature and behavior of current Mono.then(Function). This is semantically more correct as a flatMap traditionally returns the same type as the type it is called from (here Mono, not Flux). (#516)
  • Note that the deprecation notes refer one each other. If you want to try out the future behavior, keep using then and use flatMapMany instead of flatMap. You will have to migrate from then to flatMap in 3.1.0.
• Prepare migration path for deep Processor rework: connect and connectSink should not be necessary anymore, Processors now have a common sink and serialize API (#525)
• Flux/Mono error handling APIs have been realigned (#535):
  • Mono.otherwise and Flux.onErrorResumeWith aligned on onErrorResume
  • mapError aligned to onErrorMap
  • Mono.otherwiseReturn aligned to onErrorReturn
  • Mono.otherwiseIfEmpty aligned to switchIfEmpty
  • Flux.switchOnError(x) to be replaced with onErrorResume(ignore -> x)
    (notice the introduction of the lambda, but it ignores the parameter)
• Overloads of then and its variants that take a Supplier<Mono|Publisher> are deprecated (#547)
  • Instead use the simpler overloads (Publisher/Mono based) but with a Flux.defer or Mono.defer instead of the Supplier to lazily instantiate the publisher.
• The buffer and window variants that take both a Publisher and Function to respectively define the opening and closing boundaries for the buffer/window are deprecated in favor of a new bufferWhen / windowWhen variant (#542)

✨ New features and improvements

• Introduce Mono.flatMapMany and Mono.flatMap (#516)
• Introduce Flux and Mono onErrorMap (#535)
• Introduce Mono.onErrorReturn, Mono.switchIfEmtpy (#535)
• Introduce Flux.bufferWhen, Flux.windowWhen (#542)

🪲 Bug fixes

• Return new instance when chaining several Mono.untilOther (#515)
• Fix Operators#setOnce cancelling the wrong subscription
• Fix DeferredSubscription#isCancelled

📖 Documentation, Tests and Build

• add missing deprecated notice to subscribe(Consumer, int)
• Javadoc is now built with support for Java 8 apiNote tag and UTF8 charset

v3.0.6.RELEASE

This is the 6th release of Reactor 3.0, part of Aluminium-SR2 Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• In this release, we evaluated and polished ad-hoc public api usage in preparation for the next major release 3.1.0. Specifically we:
  • Deprecated Flux and Mono xxxMillis(long, ...) signatures in favor of a unique xxx(Duration) alternative. (see #436)
  • Merged the now deprecated TimedScheduler into Scheduler for an easier execution contract (see #451).
  • Deprecated Operators.SubscriberAdapter which was encouraging inefficient encapsulation.
  • Merged introspection interfaces Trackable, Loopback, Producer, Receiver, MultiReceiver and MultiProducer into a single Scannable contract for easier serviceability extension development. (see #249)
  • Deprecated ambiguous FluxSink/MonoSink.setCancellation in favor of fluent and explicit onCancel and onDispose. It's important to distinguish the various reactor shutdown states:
    • terminated == onError || onComplete
    • cancelled == cancel
    • disposed == terminated || cancelled
  • Deprecated FluxSink.serialize() since now Flux.create default to serialize (see #456), use of Flux.push can now be used alternatively for optimized single-producer push sources.
  • Aligned all error delaying aliases under combinatory conditions (merge, zip etc) to a suffixed alias standard xxxDelayError. In 3.1 we look forward giving subscribe-time option to override this behavior if the non suffixed operator alias is used. (see #480).
• Default timed operator Scheduler is now Schedulers.parallel, note that thread-name will now vary between the number of workers as in parallel-x instead of a single timed-n. (see 93a08ae)

Avoiding deprecated API now as documented in javadoc will significantly reduce the burden of updating to 3.1. We track most of the deprecated APIs marked for deletion in 3.1 in #323.

✨ New features and improvements

• Avoid unnecessary cancel events on onNext in Mono Subscribers such as operators or terminal subscribe/block calls. (see #442)
• Add Flux/Mono Duration + Scheduler aliases (see #436)
• Add FluxSink and MonoSink onCancel(Disposable) and onDispose(Disposable) (see #450, #444).
• Add Scannable to query reactor component stateful graphs (see #249).
• Add Flux.push for single producer, push-only alternative to Flux.create (see #456).
• Flux.create is now "serialized by default" and allows for multi producer push (see #456).
• Add FluxSink.onRequest(LongConsumer) to notify producer of downstream requests (see #456).
• Add Mono.whenDelayError(Iterable) (see #470)
• Add Mono.untilOther(Publisher) to coordinate on another Publisher (see #465)
• Add Flux/Mono filterWhen(Function<T, Publisher<Boolean>>> for async filtering (see #498)

🪲 Bug fixes

• Fix Flux.windowWhile replenishing issue (see #477)
• Fix Flux.concatMap prefetch to unbounded when used with Integer.MAX_VALUE (see #476)
• Fix Mono.fromRunnable fusion issue that resulted in no runnable invoked (see #455)
• Fix Flux/Mono.publish(Function) ArrayOutOfBoundsException (see #438)
• Fix Schedulers.fromExecutorService(mayInterruptIfNeeded) issue where interrupt option was ignored (see #443)
• Throwable.addSuppressed is now protected against circle reference in error handling (see #439)
• Fix TopicProcessor silently failing on backlog size == 1 (see #445)
• Fix Flux.flatMapIterable termination issue (see #453)
• Fix BaseSubscriber.dispose to actually cancel upstream (see #461)

📖 Documentation, Tests and Build

• Added some advanced use documentation (see #505)

👍 Thanks to the following contributors that also participated to this release !

@lhotari @madhead @RunninglVlan @bdavisx @nebhale

A warm welcome to @rajinisivaram as our new internal contributor. You might already have noticed her name as she is also working on the awesome https://github.com/reactor/reactor-kafka.

Finally a massive thank you to our resident reactive doctor @akarnokd and his support in various design issues, lately on the new filterWhenoperator.

v3.0.5.RELEASE

This is the 5th release of Reactor 3.0, part of Aluminium-SR1 Release Train.

This is a recommended update for all Reactor 3 users, with a lot of improvements
and small bugfixes that have notably been made possible thanks to an ongoing effort
to improve the test coverage beyond 80%.

⚠️ Update considerations and deprecations

• A number of APIs and signatures have been deprecated and are scheduled to be removed in 3.1.0.
  This should be made explicit in the associated API javadoc, but a list has been compiled in #323 too.
• Some variants of window/buffer/windowMillis/bufferMillis were ambiguous (having close variations
  of numerical parameters, int+long or long+long). The int+long ones (max size plus a timeout) have been
  renamed with a Timeout keyword, like windowTimeoutMillis (#363) (alias and deprecate)
• RejectedDisposable was not intended to be public and has been made package-private (#362)
• All closed API Supplier<Queue> checks for null have been replaced with an error throw, as they are consider fatal
• Deprecate Operators.addAndGet(AtomicLong) as not used internally, we encourage to use the other addAndGet variant or if required port this over your app/lib.
  • Exceptions.failWithCancel() is not a singleton exception anymore and Exceptions.CANCEL_STACKTRACE has been deprecated.

✨ New features and improvements

• Tuples improvements: they are now Iterator<Object> with an unmodifiable iterator, a Tuple2 and a Tuple3
  filled with nulls won't have the same hashcode anymore (base is the size), and Tuples toString format changed
  (displays nulls, enclosed in square brackets)
• Added decorator hook for ExecutorServices in Schedulers, allowing users to change the internal implementation
  for any core-provided Scheduler (#354)
• Mono and ParallelFlux now have doOnEach (#344)
• ParallelFlux now allow you to easily compose on each group's flux using composeGroup (#283)
• Generalize fromFuture with an additonal fromCompletionStage to support more future-like use cases (#357)
• Align delay APIs that delays elements on Mono and Flux by adding Mono.delayElement and prepare renaming
  of Flux.delay to Flux.delayElements (#263)
• Expose groupBy with prefetch variant (#370)
• In the same vein as for buffer, two new window operators have been introduced: windowUntil and windowWhile (#260)
• Improvements have been made to debugging and tracing user experience (#379, #361, #417)
  • identifying the source of an error from an inner flux inside eg. a flatMap, decrease performance cost of activated assembly tracing, added Flux, Mono, ParallelFlux checkpoint(description?) operator to manually apply assembly tracing
• Direct schedule Disposable can now be checked for isDisposed() (#410)
• Add transform() to onAssembly scope
• Fuseable.QueueSubscription#isEmpty() is not expected to fail anymore
• Do not wrap rejected execution exceptions (use Exceptions.propagate() instead of Exceptions.bubble()
• Check negative timeout for Schedulers.newElastic()
• Check bufferSize in Flux#onBackpressureBuffer()
• Eager cancel Flux.publish subscribers during batch of emission (#430)

🪲 Reported Bug fixes

• Fix Mono.sequenceEquals not propagating subscribe signal + doing too much inner subscribe / too few inner cancel (#328, #329)
• Mono.whenDelayError was wrongly only using last 2 params out of 3 (#333)
• Fix WorkQueueProcessor potential thread leak (#335, #336)
• Tuples and Tuple2 fixes: fixed Tuples.fromArray for size 0 and 8, (#338)
• Due to the Tuples issue above, the zipWith was failing with less than 8 sources (#338)
• MonoSink.success(null) now delegates to success() to ensure same semantics (#346)
• CachedTimedScheduler.now() correctly delegates to underlying scheduler (#351)
• Operators.addAndGet now return updated value (#372)
• An unbounded prefetch (Integer.MAX_VALUE) on groupBy triggers unbounded request (#385)
• Fix fusion on Flux.skipUntil, Flux.handle, fix fusion request handling for SubscribeOnValue (8f67283, f2404eb, #342)
  • Fix unbounded Flux.replay/cache fusion (#392)
• Use unbounded queues for groupBy, window, buffer and switchMap to avoid overflow (#411)
• Thread boundaries such as zip, flatMap or publishOn now correctly request fusion with the thread barrier flag. This means that thread expectation for upstream operators such as doOnNext or map will defeat tentative to fuse to enforce thread expectations.
• Fix Flux & ParallelFlux reduce/collect generic issue
• Fix linked queue minimum (was always minimum instead of the default size QueueSupplier.SMALL_BUFFER_SIZE or specified by user via QueueSupplier.unbounded(linkSize) !)
• Fix bi-insert logic used by switchMap/join

📖 Documentation, Tests and Build

• Various typos and wording improvements to javadocs
• First draft of a Reference Guide (#404, with a target at spring-level quality and completion for 3.1.0)
• Global effort on tests: increase overall coverage, better separate long-running tests that make less sense in CI,
  first shot at a TCK-like framework to ease coverage of new operators...
• Exclude snapshot and mavenLocal from release builds (#291)

Various changes and fixes

• Use computeIfAbsent instead of verbose null check in collectMultimap (#396)
• OSGi bundle: don't import com.google twice (#386)
• Introduce progressive upgrade to unbounded request FlatMap in preparation of #371
• Fix ParallelFlux#getPrefetch accuracy of the returned value
• Fix Mono.or optimization, add assembly on Mono.first
• Fix Mono.when array type issue
• Hooks (de)activation are now logged as DEBUG instead of INFO
• Improve common operator defensive patterns regarding fusion and RS rules
• Fuseable.SynchronousSubscription does now expect a sync request mode and will return Fuseable.NONE if requested NONE.
• Internal renaming, in particular ParallelUnordered to Parallel
• Remove instance cost where possible for ArrayDeque operators
• unbounded prefetch should now correctly return Integer.MAX_VALUE not Long.MAX_VALUE on Flux#getPrefetch(), monitor #397 for the complete migration in 3.1

👍 Thanks to the following contributors that also participated to this release

@kamilszymanski, @magnet, @mrorii, @sinwe, @dfeist and all folks who came discussing in our Gitter room, Spring team for continuous extensive collaboration and @akarnokd for his usual wisdom.

v3.0.4.RELEASE

This is the 4th release of Reactor 3.0, part of {ALUMINIUM-RELEASE} Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• Cancellation is being deprecated and will be removed in 3.1.0. The new Disposable replaces it (#322)
  • Scheduler now implements Disposable. We advise that if you have an implementation of Scheduler, you explicitly implement both shutdown() and dispose(), with the concrete code in dispose() and the shutdown() method calling dispose().
  • Same with Scheduler.Worker
• A report has been issued in #339 and might force library developers to issue a patch release recompiled against reactor-core 3.0.4 if they wish to offer third party users option to upgrade too.

✨ New features and improvements

• A new BaseSubscriber has been added to allow to easily subscribe and play
  with the request/cancel. It offers hooks, including a hookFinally that always
  execute on sequence termination (#254, #279)
• Added new buffer operators based on predicates: bufferUntil and bufferWhile (#227)
• The new doFinally operator allows to perform a side effect on any type of
  termination (onError, onComplete and cancel) (#251)
• When using a WorkQueueProcessor, a best effort attempt at detecting the capacity
  of the underlying Executor is made in order to prevent you from subscribing
  too much (#199)
• Added a doOnEach variant to Flux that takes a Consumer<Signal> (#264, #289)
• Added a onBackpressureBuffer variant that takes a BufferOverflowStrategy,
  allowing to decide what to do if the bounded buffer fills up: error, drop last
  element, drop oldest element in buffer... (#281)
• A variant of Mono.and based on a Function<T, Mono<V>> now allows to easily
  combine a value and the result of applying an asynchronous processing on it
  into a Tuple2 (#300)
• Worker now has a isShutdown() method (#313)
• A Disposable interface has been introduced, preparing to replace Cancellation. For now it extends Cancellation (#322)

🪲 Bug fixes

• FluxHandle sink always use onOperatorError (#282)
• Rework handling of RejectedExecutionException in most processors (#275, #293, #298, #274, #299, #313, #319)
  • the exception is more consistently thrown by all schedulers in case its underlying executor rejects a task because the scheduler was shut down.
• Fix the onNext/onComplete callback reversal in async-fused sequences (#230)
• A Callable returning null now always trigger onError(NPE) (#261)
• Don't silence errorNotImplemented in Schedulers (#257)
• Improve doOn callback failures handling (#247)
• Prevent logging of a Subscription as a Collection in log() (instead using
  a dedicated format), which would cause a NotImplementedException with some
  loggers applying custom logic to Collections (#262)
• Fix flatMapSequential dropping some elements when there are more than
  prefetch source elements (workaround: use same number for prefetch and
  maxConcurrency) (#301)
• Fix the sharing of state between multiple subscribers for Mono#doOnTerminate (#242)

Various changes

• Fix typos in javadoc of multiple files
• Update doc to 3.0.4.BUILD-SNAPSHOT
• Integrate reactor-test 3.0.4
• Build and tests improvements:
  • Use compileOnly configuration and RELEASE version for JSR-166 backport dependency (#291, #292)
  • Improve Travis build integration and tweak gradle tests
  • Convert some long running tests to using virtual time, separate consistency
    tests into their own category (not ran during PR integration), reduce iteration
    count in some looping tests.

👍 Thanks to the following contributors that also participated to this release

@dfeist, @wilkinsona, @akarnokd, @not-for-me

And thanks for raising issues/feedback: @dfeist, @balamaci, @srinivasvsk, @kdvolder, @gdrouet, @artembilan, @graememoss, @jurna

v3.0.3.RELEASE

This is the third release of Reactor 3.0. This is a recommended update for all Reactor 3 users.

Update considerations and deprecations

• the RxJava2 adapters have been moved to external project reactor-addons/reactor-adapter
• RxJava1Adapter support has been dropped in favor of the official rxjava-reactive-stream. Since RxJava1Adapter was broken by latest rxjava1 maintenance releases, this might not be considered a hard breaking change.
• if you used the test class TestSubscriber from the sources, it has been removed from the public API (renamed AssertSubscriber and placed in test scope until it is removed definitely). Please use the StepVerifier class in the external project reactor-addons/reactor-tests 3.0.3.RELEASE instead.
• the protected field subscriber in Operators.MonoSubscriber has been renamed actual to be consistent with the other reactor-core operators. It should only be impacting for users that have implemented their own Mono operators.
• Flux#then(Publisher<Void>) has been deprecated, use the new name thenEmpty (will be removed in 3.1, see #238)
• Flux#subscribe overrides with a prefetch parameter have been deprecated in favor of chaining the new limitRate to other variants (#225)

🐞 Known bugs

• #230 is not entirely fixed: callbacks for onNext and onComplete can still be called in wrong order, which impacts the doOnSuccess operator.
  • see discussion in PR #243. workaround: use doOnNext rather than doOnSuccess

New features and improvements

• new mergeSequential and flatMapSequential operators (#178)
  • these allow to eagerly subscribe to the merged publishers, but to keep items emitted by them in order
• new limitRate operator (#180)
  • allows to control the backpressure signal sent to the upstream instead of relying on downstream backpressure signals that may be too high, effectively rate limiting the upstream
• cached schedulers are reset and shutdown upon setFactory, and are now a Supplier<Scheduler> (#218)
• added subscribe variants with a Consumer<Subscription> callback (#196)
• macro and micro optimizations in Flux (fromStream, thenMany, zip) and Mono (when, and, or and thenMany) (#240, #237)

Bug fixes

• don't share doOnSuccess state (#232)
• fix MonoSubscriber fusion logic (#230)
• fix PeekFuseableSubscriber#poll not using Operators.onOperatorError (#205)
• cancel Subscription on consumer error (#212)
• self Suppression IllegalArgumentException when 'onErrorResume' propagates existing exception (#204)
• make Scheduler shutdown consistent handling with future.cancel(true/false)
• do not override subscription with a cancelled one (#202)
• various fixes synchronized from reactive-streams-commons (#215)
• improves error handling for flow with doOnError and subscribe (#190)

Various changes

• various code cleanups and javadoc improvements
• increased test coverage
• a first step in the direction of harmonizing Flux and Mono thenXXX APIs (#238, #198)
• exported IntelliJ inspection profile, renamed code style configuration in /codequality/idea
• ring buffer code missing attribution to https://lmax-exchange.github.io/disruptor/ (#229)
• reduce logging level used in Hooks.onXX (#213)
• use j.u.Objects in Signal equals and toString

Thanks to the following contributors that also participated to this release 👍 : @dfeist @poutsma @snicoll @akarnokd

v3.0.2.RELEASE - Reactor 3.0 GA !

Welcome to Reactor 3.0 !

v3.0.1.RELEASE

Full list of changes and fix : https://github.com/reactor/reactor-core/milestone/7?closed=1

v3.0.0.RELEASE

[artifactory-release] Release version 3.0.0.RELEASE

v3.0.0.RC2

Changes from RC1:

• name consistency fixes on Sinks : fail -> error, MonoSink#complete -> success
• remove MonoSink interface from MonoProcessor
• remove fromCallableOrEmpty in favor of Mono#create
• remove RingBuffer from surface API
• fix Mono#when and #whenDelayError vararg/iterable signatures
• remove TestSubscriber
• generic "handle" operator, removing immediate need for lifting and tricks for error handling
• global error hooks
• TupleXx fields are no longer public, use Getters only.
• global debug mode that auto adds logging , maybe combined with an open global hook for assembly
• Rework some operator error utils from Exceptions linked to global state into new Hooks
• the end of ComputationScheduler since SingleScheduler is enough for the use case of non blocking task runs
• New Flux#doOnEach and Flux/Mono#doOnLifecycle
• more scheduler hooks
• porting rx join/groupJoin operators