NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Maven Central, #952 by repository stars
Reactor Test support
Latest stable
3.9.0
Last release 2 days ago
20 Nov 2026
Ships fairly regularly
a new release about every 5 weeks
Nearly every release is documented
notes for 59 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
7 years old
185 releases · first in 2019
Drag across the ruler to compare, or tap a release to open it.
This is the 4th release of Reactor 3.1, part of `BISMUTH-SR6` Release Train.
This is the 4th release of Reactor 3.1, part of BISMUTH-SR6 Release Train.
This is a recommended update for all Reactor 3 users.
Queue implementation from 3.1.3.RELEASE shouldn't have been public (#1010, #1035)
Queue through Queues.unboundedMultiproducer()FluxDelaySequence, FluxIndex and FluxIndexFuseableContext as part of Flux.repeatWhen and Flux.retryWhen companion flux triggers a specific behavior (#1048)
Context, which acts as a trigger for resubscription to the source, replaces the original Context of the
xxxWhen operator and becomes visible to the upstream from that point.Context from the original Context, otherwise you risk blindly deleting keys from the original that 3rd party libraries rely on. (this is described in the javadoc)Flux.zip, Mono.zip short-circuits on the first source that terminates empty, cancelling other pending sources (#1071)
Mono<Void> source or any empty Mono<T> completes. this could lead to earlier than expected completions.Mono.zip(...).then() pattern in your code and replace that with Mono.when(...) instead, as when does wait for all completions and results in a Mono<Void>.Mono.zipDelayError, which
won't cancel other sources (aggregating to a composite onError in case of 1+ errors, or an empty mono in case
of 0 error and 1+ empty sources)log now has a variant that directly takes a Logger instance, which can improve performance if the bottleneck
is the resolution of Loggers (#956)mergeOrdered, has been added to Flux and ParallelFlux (#963)Flux.concatWithValues(T...) and Mono.thenReturn(T) have been added to conveniently concat/continue with
scalar values (#1029)distinct now allows for arbitrary backing store, not necessarily a Collection, if you also provide a
"distinct check" BiPredicate (#1054)Context as part of Flux.repeatWhen and Flux.retryWhen companion flux triggers a specific behavior (see update considerations above, #1048)Scheduler and Worker are now Scannable (#1050)
Scannable.from(schedulerInstance)ExecutorService-backed schedulers can offer a degree of insight into their executor if it is a ThreadPoolExecutor, via
scanning of CAPACITY and BUFFEREDExecutors.newSingleThreadExecutor (which isn't introspectable by the above
method) are now backed by a ThreadPoolExecutor with a corePoolSize == maxPoolSize of 1.Scheduler as parameter can return that Scheduler or the Worker they use via a scan()
of the new Attr.RUN_ON attribute. A Scannable.UNAVAILABLE_SCAN is returned if that information is not available (dcc36e5)doOnEach could be ignored in case of a Fuseable source, due to a mistake in the way it would call its
downstream onSubscribe method with its source rather than itself (#1056, #1067)elastic Scheduler would retain a reference to all its expired workers, which has now been fixed (#1070)TopicProcessor and WorkQueueProcessor forceShutdown() method would fail to shut down the "request task"
backing ExecutorService (#1074)Flux.zip, Mono.zip short-circuits on the first source that terminates empty, cancelling other pending sources
(see update considerations above, #1071)japicmp now has the previous 3.1.3.RELEASE as baseline (1c0fa6d)verify() call, and as such not testing anything (#1046)@anonymousXrandom, @KPull, @pcroc, @sbuettner, @yilinwei
Your coding agent can read these notes before it upgrades. Set up the MCP server →
EventLoopProcessor#shutdownAndAwait(long, TimeUnit) has been deprecated
This is the 3rd release of Reactor 3.1, part of BISMUTH-SR5 Release Train.
This is a recommended update for all Reactor 3 users.
bufferWhen and windowWhen (which are also backing their timeout based variants) have changed, fixing leaks in the process.distinct()/distinctUntilChanged() now use the full object (with a HashSet) instead of just the extracted hashcode() for their distinct criteria (#1025)EventLoopProcessor#shutdownAndAwait(long, TimeUnit) has been deprecated (#986)should NOT be used. A patch release will fix their scope back to package scope.log() now logs errors using debug()/trace() (#967)parallelism() (#968)EventLoop based Processors now have a Duration based shutdownAndAwait (#986)Context testing features (#901, #898)delaySequence operator to Flux, that just shifts the sequence forward in time (#989)Context accessible through Signal from materialize and doOnEach (#947, #1004)distinct()/distinctUntilChanged() criteria (#1025)doFinally even if subscribe() throws (#951)windowWhile now replenishes on premature cancel (#1017)windowWhen (#975)bufferWhen Flux (#969, 170f39b)@glyn, @OlegDokuka, @onionf91, @stamhankar999
This is the 3rd release of Reactor 3.1, part of `BISMUTH-SR4` Release Train.
This is the 3rd release of Reactor 3.1, part of BISMUTH-SR4 Release Train.
This is a recommended update for all Reactor 3 users. It notably contains a new Flux operator called index to index as a Tuple<Long, T> or any arbitrary container each element from a sequence.
Flux#index operator (#934)Mono#single to enforce the presence of an element in a Mono<T> (#940)Mono#blockOptional to block and return an Optional (#918)Flux#fromStream(Supplier<Stream>) (#922)timeout operator (#925)Mono from a Supplier (#929)concatDelayError and concatMapDelayError with Mono.error (#936)Context simple example in reference guide (#921)Mono.repeatWhenEmpty (#919)cache(Duration) javadoc (#930)Context content in test (#950)Scheduler javadoc (#935)@baptistemesta, @naxhh
This is the 2nd release of Reactor 3.1, part of `BISMUTH-SR2` Release Train.
This is the 2nd release of Reactor 3.1, part of BISMUTH-SR2 Release Train.
This is a recommended update for all Reactor 3 users. It notably contains an important fix for a Flux#windowTimeout bug introduced in v3.1.0.
interval has been clarified, making it clearer that interval doesn't really support backpressure (#911)limitRequest operator will strictly cap the total request (without prefecthing, unlike limitRate) and limitRate now has a variant that takes a lowTide parameter that allow to customize the replenishing amount (#879, #894)Publisher with toFlux and toMono operations (#908)Flux#windowTimeout with <10ms timeouts could trigger race conditions and lose some windows/drop data to already closed windows. The operator has consequently been reworked (#912)dispose() (#880)Scannable scanning of PARENT and ACTUAL always returns a Scannable, even if the original unsafe scan didn't. In the later case, the UNAVAILABLE_SCAN instance is returned (#895)ParallelFlux (.parallel()) is now considered a THREAD_BARRIER for fusion purposes, allowing sensitive operators to skip fusion (#905)reactor-extra (#899)japicmp (#884)@0xflotus, @Buzzardo, @kadyana, @quaff, @sdeleuze
Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)
This is the first release of Reactor 3.1, part of Bismuth-RELEASE Release Train.
This version is a recommended update for all Reactor 3 users, and will be the one backing Spring Framework 5.0. A lot of API polishing has occurred between the last 3.0.x release and this one, so please read the release notes below carefully if you didn't progressively upgrade through the various MILESTONEs and RCs. (if you only care about what changed since RC1, please have a look at the RC2 release note)
The release notes below are written from the perspective of a migration from 3.0.x latest version and cover changes across all the 3.1.0 pre-releases.
Note that since pre-release v3.1.0.M2, the source code for the reactor-test artifact is part of the reactor-core github repository.
Reactor has been updated to pass the TCK of the new Reactive Streams specification 1.0.1.RC2. A new StrictSubscriber enforces RS rules more strictly when going out of the Reactor world and bridging to an external Publisher (#711)
The reactor-test artifact is now part of the io.projectreactor groupId (and reactor-core github repository)
Kotlin extensions for core and test are now part of the reactor-core repo and artifacts
behavioral changes
doAfterTerminate doesn't cause an onError signal if its callback fails (#270)sample will now include the last element in the source sequence if it terminates with an open sampling window (#724)Flux.cache(Duration) now expires the termination signal as well (#750)Flux/Mono method changes
ParallelFlux#subscribe(lambdas) lambda-based variants now return a Disposable (composite of all rails subscribers, #800)Flux#toIterable now takes an int for its batchSize argument (f3e13bf)Mono.doOnTerminate and doAfterTerminate now take a simple Runnable (aligning the API with Flux). The old doOnTerminate(BiConsumer<Throwable, T>) can be achieved with the added doOnSuccessOrError and old doAfterTerminate(BiConsumer<Throwable, T>) with doAfterSuccessOrError(BiConsumer<Throwable, T>). (#836 + 80a3210)Flux.firstEmitting is now called first and Flux.firstEmittingWith is now called or, aligning APIs with those of Mono (#849)Mono.empty(Publisher<?>) has been removed, prefer using the new Mono.when(p) (2e7fdf3)(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)Mono#untilOther removed (use delayUntil(it -> other.take(1)) instead, see #558)then:
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 thenEmptyMono.then(Function) is now Mono.flatMapMono zip vs when
zip is the operator dedicated to producing Tuples (or equivalent combinations) of the elements from multiple sources.
As a consequence, when and and variants that produced a Tuple have now been renamed zip and zipWith (#789 + 52f7f04)when and and still exist, as operators in the same family as then: they only care about completion signals,
discarding elements and returning a Mono<Void>.Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)zip(Iterable) and zip(Function, Iterable)in Flux has been removed (#338, #619):warning: Mono.then(Function) and Mono.flatMap(): how to migrate (#516):
Mono.flatMap with flatMapManyMono.then(Function) (which has been removed) with flatMap.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 -> onErrorMapwindow:
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)Flux.windowTimeOrSize: the timeout now starts right from subscription, resulting in potentially empty windows being emitted. It also restarts if the
timeout expires, so there could be several empty windows emitted eg. 3 for a timeout of 100ms if the Flux doesn't emit for 300ms.
The equivalent buffer version remains unchanged. (#484)windowUntil/windowWhile have Flux windows instead of GroupedFlux (#759)Cross operator changes based on prefix / parameter pattern:
Millis suffix have been removed, use their Duration based counterpartsxxx(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>subscribe methods in Flux that had a prefetch parameter have been removed (you can use limitRate to achieve the same effect)class changes
Signal is now an interface and MutableNextSignal has been removed (#779)Scannable interface (Loopback, MultiProducer, MultiReceiver, Producer, Receiver, Trackable, see #249, 20bd64df)Cancellation has been removed and replaced with Disposable (see #322, 844769d4)TimedScheduler has been removed, as well as the Scheduler#shutdown method (most schedulers are now fully time capable and you can use dispose(). The few Scheduler that are not time-capable will throw a RejectedExecutionException indicating so whenever one attempts to use schedulePeriodically on them. Note that most timed operators now use the parallel() Scheduler by default. (see #451, #322)OpenHashSet has been removed, as it was only used for Disposables: use Disposables.composite() (40fbd60)QueueSupplier has been renamed to Queues and is now purely about queue-related utils and static suppliers. It doesn't implement Supplier<Queue> itself anymore. (#733)Hooks
Hooks are now cumulative. Setting a hook will add it on top of the existing one(s). You can also name
some hooks, which allows to update a sub-hook or only partially reset a hook. (#687, #784)onEachOperator + onLastOperator, now Function<Publisher, Publisher>, new operator lift (#775)Context (#830)nullability
Tuple (#696)Processors have been reworked:
sink() method. For details and rationale, see #525.TopicProcessor, WorkQueueProcessor) now have a Builder instead of
factory methods. However, they keep a couple of significant factory methods (see #471, #616 and #628)Mono#subscribe() returns a Disposable. Use .toProcessor() to get the exact legacy behavior (see #566, #605 and #638)UnicastProcessor won't ignore the overflowStrategy if we can detect that a bounded queue is used. By default, an unbounded queue is used and the strategy is silently ignored. (#612)DirectProcessor and UnicastProcessor now call onErrorDropped and onNextDropped if calling after terminate. Exceptions.argumentIsNullException() has been removed (most of the time replaced by Objects.requireNonNull()). (7f6ff86)CancellationException (#792)Some changes have been made to the way writing custom operators works
Operators.SubscriberAdapter is not part of the public API anymore.Operators.addAndGet(AtomicLong, ...) has been removed in favor of the AtomicLongFieldUpdater alternative, itself renamed to addCap (#371)MonoSource and FluxSource are now package private, superseded by MonoOperator and FluxOperator (to deal with
new CoreSubscriber)Operators.onNextDropped default behaviour is to log the drop rather than throw a "fail with cancel" exception (#823)Context to a reactive sequence :sparkles: (Flux or Mono) is now possible. This is the major new feature in this milestone. (#117, #210, #337, #447, #704, #705, #723 and various other PRs)
Context can be created using factory methodsCoreSubscriber, a Reactor-specific Subscriber common to all Flux and Mono operators and needed to pass along the ContextFlux#subscribe(Subscriber) is now final, and one needs to instead implement subscribe(CoreSubscriber) in custom operators / Flux.subscriberContext(Function<Context, Context>).Mono#currentContext that can be used to emit the Context initialized downstream of it (or propagated inside eg. a flatMap)Context (b576f7f)Flux.error and Mono.error are now ScalarCallable and the error case can be fused when source is scalar (#716)Scannable classes via an Attr key. Attributes are quasi-enumerations exposing constants rather than enums. This allows splitting them into typed keys with meaningful global defaults so that scan doesn't need a Class to attempt a cast. Operator implementation is based on a Object scan, scanUnsafe.(see #606, #728)Mono#fromCallable/fromSupplier now map null result to empty Mono (#743)subscribeOn (#777)take(Duration) and takeUntilOther(Publisher) to Mono (#797)Disposables utility class ( #799, #804, #812)Mono.cache(Duration) (#683)distinctUntilChanged variant with a bipredicate to evaluate if there is a change (#608)onBackpressureBuffer variant with a TTL (#296)StepVerifier#verify() (#651)Mono.fromRunnable, the resulting Mono's generic type is better inferred (#686)checkpoint description is included inFlux/MonoSource#toString (#611)checkpoint(String) is now light by default, lowering the cost of using that operator (see #587)refCount now has a variant that waits for a grace period before unsubscribing from upstream (#569, #624, #627)Flux.then(Mono) operator to align with the Mono equivalent (#547)Mono.delayUntil to delay the emission of a Mono until after a companion Publisher generated from the source value completes. This acts on onComplete, unlike now removed untilOther. (#558, #568, #674)ParallelSubscriber now has a subscribe() method and all subscribe(...) methods are final like in Flux (#564)StepVerfier improvements:
Step#expectNext for up to 6 parameters (reactor/reactor-addons#106)expectNextSequence should fail when checking empty Flux (reactor/reactor-addons#98)MonoDelayElement (#749)Attr.LARGE_BUFFERED defaults back to null (as in "irrelevant") (#751)flattenIterable polling failures (#841)windowTimeout rejection double cancel (31ef92d)Subscription#request throws/errors (4d61440, decfa13)StepVerifier now ignores empty multivalue expectations, which could previously lead to bad assertions (#650)Flux#then and Mono#then would use arrays of incompatible types, resulting in an ArrayStoreException (#661)doOnNext callback would fail, when fused it wouldn't be caught by a doOnError (#664)filterWhen had a bug in tracking request and produced amount, resulting in under-requesting hangs (#689, #692)MonoProcessor could unnecessarily retain references to objects from its source. This is fixed by nulling out the source upon all terminations (#690)MonoProcessor#block() had a legacy inner timeout. It will now indefinitely wait for the actual completion. On the other hand, using a negative or 0 timeout in the Duration-based variant will now immediately time out. (#722)scan accumulation in a live reduction with a seed would always lag by one. It has been modified so that the seed is sent immediately, which allows the accumulator to run in lockstep with the upstream stage. (#609)Flux.create, setting an onDispose callback on the Sink after its onRequest method was called was ignored. The callback is now explicitly invoked if set after the sink was terminated. (#643)SingleScheduler.schedule (#578)Mono.untilOther would not return a new instance when chained with itself (#515)Operators#setOnce was cancelling the wrong subscriptionFlux 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, #644, #469, #521, #698, 2cd83c2)(and all the intermediate milestones)
@akarnokd, @buzzardo, @Dmitriusan, @fabriziofortino, @garyrussell, @helmbold, @IlyaZinkovich, @jakekdodd, @jimhorng, @kamilszymanski, @lebannen, @making, @markotron, @olibye, @rajinisivaram, @sdeleuze, @schauder, @TomekJurkowski, @violetagg, @zgagnon
One column per quarter.