All Versions
75
Latest Version
Avg Release Cycle
-
Latest Release
-

Changelog History
Page 4

  • v1.0.1 Changes

    • Align publisher implementation with Reactive TCK.
    • ๐Ÿ— Reimplement future coroutine builders on top of AbstractCoroutine (#751).
    • ๐ŸŽ Performance optimizations in Dispatchers.Default and Dispatchers.IO.
    • ๐Ÿ— Use only public API during JavaFx instantiation, fixes warnings on Java 9 and build on Java 11 (#463).
    • ๐Ÿ“š Updated contract of CancellableContinuation.resumeWithException (documentation fix, see #712).
    • ๐Ÿ— Check cancellation on fast-path of all in-place coroutine builders (withContext, coroutineScope, supervisorScope, withTimeout and withTimeoutOrNull).
    • โž• Add optional prefix to thread names of ExperimentalCoroutineDispatcher (#661).
    • ๐Ÿ›  Fixed bug when ExperimentalCoroutineDispatcher could end up in inconsistent state if Thread constructor throws an exception (#748).
  • v1.0.0 Changes

    • ๐Ÿš€ All Kotlin dependencies updated to 1.3 release version.
    • ๐Ÿ›  Fixed potential memory leak in HandlerDispatcher.scheduleResumeAfterDelay, thanks @cbeyls.
    • ๐Ÿ‘ yield support for Unconfined and immediate dispatchers (#737).
    • ๐Ÿ“š Various documentation improvements.
  • v1.0.0-RC1 Changes

    • โšก๏ธ Coroutines API is updated to Kotlin 1.3.
    • ๐Ÿšš Deprecated API is removed or marked as internal.
    • โš  Experimental and internal coroutine API is marked with corresponding kotlin.experimental.Experimental annotation. If you are using @ExperimentalCoroutinesApi or @InternalCoroutinesApi you should explicitly opt-in, otherwise compilation warning (or error) will be produced.
    • ๐Ÿ‘ Unconfined dispatcher (and all dispatchers which support immediate invocation) forms event-loop on top of current thread, thus preventing all StackOverflowErrors. Unconfined dispatcher is now much safer for the general use and may leave its experimental status soon (#704).
    • ๐ŸŽ Significantly improved performance of suspending hot loops in kotlinx.coroutines (#537).
    • Proguard rules are embedded into coroutines JAR to assist jettifier (#657)
    • ๐Ÿ›  Fixed bug in shutdown sequence of runBlocking (#692).
    • ๐Ÿ—„ ReceiveChannel.receiveOrNull is marked as obsolete and deprecated.
    • ๐Ÿ—„ Job.cancel(cause) and ReceiveChannel.cancel(cause) are deprecated, cancel() returns Unit (#713).
  • v0.30.2 Changes

    • ๐Ÿ‘€ Dispatchers.Main is instantiated lazily (see #658 and #665).
    • Blocking coroutine dispatcher views are now shutdown properly (#678).
    • Prevent leaking Kotlin 1.3 from atomicfu dependency (#659).
    • Thread-pool based dispatcher factories are marked as obsolete (#261).
    • ๐Ÿ›  Fixed exception loss on withContext cancellation (#675).
  • v0.30.1 Changes

    ๐Ÿš€ Maintenance release:

    • โž• Added Dispatchers.Main to common dispatchers, which can be used from Android, Swing and JavaFx projects if a corresponding integration library is added to dependencies.
    • โœ… With Dispatchers.Main improvement tooling bug in Android Studio #626 is mitigated, so Android users now can safely start the migration to the latest kotlinx.coroutines version.
    • ๐Ÿ›  Fixed bug with thread unsafety of shutdown sequence in EventLoop.
    • โœ… Experimental coroutine dispatcher now has close contract similar to Java Executor, so it can be safely instantiated and closed multiple times (affects only unit tests).
    • โšก๏ธ Atomicfu version is updated with fixes in JS transformer (see #609)
  • v0.30.0 Changes

    • [Major] Further improvements in exception handling — no failure exception is lost.
      • async and async-like builders cancel parent on failure (it affects CompletableDeferred, and all reactive integration builders).
      • This makes parallel decomposition exception-safe and reliable without having to rember about awaitAll (see #552).
      • Job() wih parent now also cancels parent on failure consistently with other scopes.
      • All coroutine builders and Job implementations propagate failure to the parent unless it is a CancellationException.
      • Note, "scoping" builders don't "cancel the parent" verbatim, but rethrow the corresponding exception to the caller for handling.
      • SupervisorJob() and supervisorScope { ... } are introduced, allowing for a flexible implementation of custom exception-handling policies, see a [new section in the guide on supervision](docs/topics/exception-handling.md#supervision).
      • Got rid of awaitAll in documentation and rewrote currentScope section (see #624).
    • [Major] Coroutine scheduler is used for Dispatchers.Default by default instead of deprecated CommonPool.
      • "DefaultDispatcher" is used as a public name of the default impl (you'll see it thread names and in the guide).
      • -Dkotlinx.coroutines.scheduler=off can be used to switch back to CommonPool for a time being (until deprecated CommonPool is removed).
    • ๐Ÿ‘€ Make CoroutineStart.ATOMIC experimental as it covers important use-case with resource cleanup in finally block (see #627).
    • ๐Ÿ‘€ Restored binary compatibility of Executor.asCoroutineDispatcher (see #629).
    • ๐Ÿ›  Fixed OOM in thread-pool dispatchers (see #571).
    • ๐Ÿ‘€ Check for cancellation when starting coroutine with Dispatchers.Unconfined (see #621).
    • ๐ŸŽ A bunch of various performance optimizations and docs fixes, including contributions from @AlexanderPrendota, @PaulWoitaschek.
  • v0.27.0 Changes

    • [Major] Public API revision. All public API was reviewed and marked as preparation to 1.0 release:
      1. @Deprecated API. All API marked as deprecated will be removed in 1.0 release without replacement.
      2. @ExperimentalCoroutinesApi API. This API is experimental and may change in the future, but migration mechanisms will be provided. Signature, binary compatibility and semantics can be changed.
      3. @InternalCoroutinesApi. This API is intended to be used only from within kotlinx.coroutines. It can and will be changed, broken and removed in the future releases without any warnings and migration aids. If you find yourself using this API, it is better to report your use-case to Github issues, so decent, stable and well-tested alternative can be provided.
      4. @ObsoleteCoroutinesApi. This API has serious known flaws and will be replaced with a better alternative in the nearest releases.
      5. Regular public API. This API is proven to be stable and is not going to be changed. If at some point it will be discovered that such API has unfixable design flaws, it will be gradually deprecated with proper replacement and migration aid, but won't be removed for at least a year.
    • [Major] Job state machine is reworked. It includes various performance improvements, fixes in ๐Ÿ‘ป data-races which could appear in a rare circumstances and consolidation of cancellation and exception handling. ๐Ÿ‘€ Visible consequences of include more robust exception handling for large coroutines hierarchies and for different kinds of CancellationException, transparent parallel decomposition and consistent view of coroutines hierarchy in terms of its state (see #220 and #585).
    • ๐Ÿ‘€ NIO, Quasar and Rx1 integration modules are removed with no replacement (see #595, #601, #603).
    • ๐ŸŽ withContext is now aligned with structured concurrency and awaits for all launched tasks, its performance is significantly improved (see #553 and #617).
    • โž• Added integration module with Play Services Task API. Thanks @SUPERCILEX and @lucasvalenteds for the contribution!
    • ๐Ÿ‘€ Integration with Rx2 now respects nullability in type constraints (see #347). Thanks @Dmitry-Borodin for the contribution!
    • ๐Ÿ‘€ CompletableFuture.await and ListenableFuture.await now propagate cancellation to the future (see #611).
    • ๐Ÿ‘€ Cancellation of runBlocking machinery is improved (see #589).
    • Coroutine guide is restructured and split to multiple files for the sake of simplicity.
    • ๐Ÿ‘€ CoroutineScope factory methods add Job if it is missing from the context to enforce structured concurrency (see #610).
    • ๐Ÿ‘€ Handler.asCoroutineDispatcher has a name parameter for better debugging (see #615).
    • ๐Ÿ›  Fixed bug when CoroutineSchedule was closed from one of its threads (see #612).
    • ๐Ÿ‘€ Exceptions from CoroutineExceptionHandler are reported by default exception handler (see #562).
    • ๐Ÿ‘€ CoroutineName is now available from common modules (see #570).
    • โšก๏ธ Update to Kotlin 1.2.70.
  • v0.26.1 Changes

    • ๐ŸŽ Android Main dispatcher is async by default which may significantly improve UI performance. Contributed by @JakeWharton (see #427).
    • ๐Ÿ›  Fixed bug when lazily-started coroutine with registered cancellation handler was concurrently started and cancelled.
    • ๐Ÿ‘Œ Improved termination sequence in IO dispatcher.
    • ๐Ÿ›  Fixed bug with CoroutineScope.plus operator (see #559).
    • ๐Ÿ“š Various fixes in the documentation. Thanks to @SUPERCILEX, @yorlov, @dualscyther and @soudmaijer!
  • v0.26.0 Changes

    • ๐Ÿ‘€ Major rework of kotlinx.coroutines concurrency model (see #410 for a full explanation of the rationale behind this change):
      • All coroutine builders are now extensions on CoroutineScope and inherit its coroutineContext. Standalone builders are deprecated.
      • As a consequence, all nested coroutines launched via builders now automatically establish parent-child relationship and inherit CoroutineDispatcher.
      • All coroutine builders use Dispatchers.Default by default if CoroutineInterceptor is not present in their context.
      • CoroutineScope became the first-class citizen in kolinx.coroutines.
      • withContext block argument has CoroutineScope as a receiver.
      • GlobalScope is introduced to simplify migration to new API and to launch global-level coroutines.
      • currentScope and coroutineScope builders are introduced to extract and provide CoroutineScope.
      • Factory methods to create CoroutineScope from CoroutineContext are introduced.
      • CoroutineScope.isActive became an extension property.
      • New sections about structured concurrency in core guide: ["Structured concurrency"](docs/topics/coroutines-guide.md#structured-concurrency), ["Scope builder"](docs/topics/coroutines-guide.md#scope-builder) and ["Structured concurrency with async"](docs/topics/coroutines-guide.md#structured-concurrency-with-async).
      • New section in UI guide with Android example: ["Structured concurrency, lifecycle and coroutine parent-child hierarchy"](ui/coroutines-guide-ui.md#structured-concurrency,-lifecycle-and-coroutine-parent-child-hierarchy).
      • Deprecated reactive API is removed.
    • ๐Ÿ‘€ Dispatchers are renamed and grouped in the Dispatchers object (see #41 and #533):
      • Dispatcher names are consistent.
      • Old dispatchers including CommonPool are deprecated.
    • ๐Ÿ›  Fixed bug with JS error in rare cases in invokeOnCompletion(onCancelling = true).
    • ๐Ÿ›  Fixed loading of Android exception handler when Thread.contextClassLoader is mocked (see #530).
    • ๐Ÿ›  Fixed bug when IO dispatcher silently hung (see #524 and #525) .
  • v0.25.3 Changes

    • ๐Ÿ‘€ Distribution no longer uses multi-version jar which is not supported on Android (see #510).
    • JS version of the library does not depend on AtomicFu anymore: ย  All the atomic boxes in JS are fully erased.
    • ๐Ÿš€ Note that versions 0.25.1-2 are skipped for technical reasons (they were not fully released).