Description

Your code can’t afford to waste resources or block important threads. Whether you’re juggling dozens of inputs and outputs, keeping user interfaces smooth and snappy, or parallelizing heavy workloads, you need a dependable way to write asynchronous code that’s responsive, readable, and reliable. Coroutines combine the benefits of asynchronous execution with the straightforward sequential style of familiar blocking functions, so you can write your code the way you want and let Kotlin take care of running it efficiently.

Build a mental toolkit of coroutine idioms. Following step-by-step examples and real-world explanations, you’ll speed up your code and improve user experiences. Use structured tasks to safely manage errors and resources. Unlock new suspending functions and old control flow possibilities, all while integrating seamlessly with the tools and libraries you already know. Match coroutine tools instinctively to common tasks, and collaborate with confidence when you follow suspending function conventions.

Peek below the surface and see how coroutines keep you safe behind the scenes. Diagnose problems before they happen, and rely on the Three Rules of Jobs to sidestep concurrency pitfalls. Debug and test asynchronous operations, and ship coroutines that make life easy for you, your coworkers, and your users.

Contents and Extracts

Introduction

• Best of Both Worlds
  • Wait Without Worrying
    • What Is a Coroutine?
    • Suspend Your First Function
    • Keep the Main Thread Clear
    • What Have You Learned?
  • Escape From Callback Hell
    • Plot Your Program’s Path
    • Reclaim Control-Flow Keywords
    • Excavate the Indentation Pyramid
    • What Have You Learned?
  • Start It, Scope It, Stop It
    • Access Suspending Functions Anywhere
    • Fix a Scope to Plug a Memory Leak
    • Get Rid of Unwanted Tasks
    • What Have You Learned?
  • Split Up to Speed Up excerpt
    • Write Code That Can Multitask
    • Download Two Things at Once
    • What Have You Learned?
  • Plan for Any Outcome
    • Build a Hierarchy of Tasks and Subtasks
    • Keep Track of Every Exception
    • Customize Your Error Handling
    • What Have You Learned?
  • Cooperate with Cancellation
    • Give a Task a Time Limit
    • Keep Clear of Cancellation Exceptions
    • Suspend a Canceled Coroutine
    • What Have You Learned?
  • Unlock Parallel Processing excerpt
    • Launch Millions of Tasks
    • Dispatch to Multiple Cores
    • Teach a Selfish Function to Share
    • What Have You Learned?
• Better Together
  • Call Blocking Functions Safely
    • Keep Your Functions Honest
    • Block That Thread, Not This One
    • Make Hard Work Look Easy
    • What Have You Learned?
  • Upgrade Every Callback
    • Mix Coroutines and Futures
    • Build Your Own Suspension Point
    • Lift the Continuation Curtain
    • What Have You Learned?
  • Go with the Flow
    • Run, Return, Resume, Repeat
    • Wrap It Up Safely
    • Download Page After Page
    • What Have You Learned?
  • Operate the Reactive Way
    • Transform from Flow to Flow
    • End a Flow Early
    • Publish a Reactive Stream
    • What Have You Learned?
  • Share Flows, Connect Channels excerpt
    • Communicate Between Coroutines
    • React to a Repeating Callback
    • Share Once, Observe Everywhere
    • What Have You Learned?
  • Unit Test Without Delay
    • Write Quick Tests for Slow Code
    • Expand Your Testing Toolkit
    • What Have You Learned?