Kotlin Concurrency with Coroutines: Harness Suspended Functions, Channels, and Flows with Configurable Dispatchers for R, (Paperback)

Stop writing concurrent code that is complex, error-prone, and difficult to maintain. "Kotlin Concurrency with Coroutines" is your definitive guide to mastering lightweight, structured concurrency, allowing you to build resilient, high-throughput applications with code that is as simple to read as it is powerful.

This book moves beyond the "what" and dives deep into the "how" and "why" of modern asynchronous programming in Kotlin. You'll leave behind the complexities of legacy threading and callback-based-hell, and instead, you will harness a fully-structured, non-blocking model to build systems that scale.

We'll systematically dissect the core components of coroutines, transforming you from a developer who uses coroutines into an architect who understands them.

Inside this book, you will master:

• Suspended Functions (The "Why"): Go beyond the suspend keyword. Learn how continuations work under the hood, enabling you to write asynchronous, non-blocking code that looks and feels perfectly synchronous and sequential.
• Configurable Dispatchers (The "Where"): Take full control of execution. Master the built-in dispatchers (Main, IO, Default) to move work off the UI thread or optimize for CPU-bound vs. I/O-bound tasks. You will also learn to configure custom thread pools for fine-grained performance tuning.
• Channels (The "How"): Implement robust, thread-safe communication patterns. Build high-throughput producer-consumer pipelines, fan-out, and fan-in data processing systems that manage backpressure and prevent resource exhaustion.
• Flows (The "What"): Tame asynchronous data streams. Learn to use Kotlin's modern, reactive stream-processing API. You will master Flow to handle everything from simple data sequences to complex, real-time events, all while managing backpressure and ensuring resilience.
• Resilience and Structured Concurrency: Build applications that don't fail. Learn to use supervisorScope, structured error handling, and cancellation patterns to create fault-tolerant systems where one failure doesn't cascade and bring down your entire application.

This book is for:

• Android and Kotlin Developers who need to build responsive, jank-free UIs by moving heavy work off the main thread.
• Backend Engineers building high-throughput microservices and data-processing pipelines that must handle thousands of concurrent requests.
• Java Developers migrating to Kotlin and looking for a modern, superior alternative to the ExecutorService and CompletableFuture models.

By the end of this book, you won't just be using coroutines-you'll be thinking in them. You will have the expert-level knowledge required to design and deploy sophisticated, high-performance, and incredibly resilient concurrent systems.