Book Image

Learning Concurrency in Kotlin

By : Miguel Angel Castiblanco Torres
Book Image

Learning Concurrency in Kotlin

By: Miguel Angel Castiblanco Torres

Overview of this book

Kotlin is a modern and statically typed programming language with support for concurrency. Complete with detailed explanations of essential concepts, practical examples and self-assessment questions, Learning Concurrency in Kotlin addresses the unique challenges in design and implementation of concurrent code. This practical guide will help you to build distributed and scalable applications using Kotlin. Beginning with an introduction to Kotlin's coroutines, you’ll learn how to write concurrent code and understand the fundamental concepts needed to write multithreaded software in Kotlin. You'll explore how to communicate between and synchronize your threads and coroutines to write collaborative asynchronous applications. You'll also learn how to handle errors and exceptions, as well as how to work with a multicore processor to run several programs in parallel. In addition to this, you’ll delve into how coroutines work with each other. Finally, you’ll be able to build an Android application such as an RSS reader by putting your knowledge into practice. By the end of this book, you’ll have learned techniques and skills to write optimized code and multithread applications.

Related Content you might be interested in

Current Title:

Small book image
Learning Concurrency in Kotlin
Miguel Angel Castiblanco Torres
Jul, 2018 | 266 pages
Small book image
Simplifying Android Development with Coroutines and Flows
Jomar Tigcal
Jul, 2022 | 164 pages
Small book image
Learn Kotlin Programming
Stephen Samuel | Stefan Bocutiu
May, 2019 | 514 pages
Small book image
Kotlin Design Patterns and Best Practices
Alexey Soshin
Jan, 2022 | 356 pages
Table of Contents (11 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Hello, Concurrent World!
Hello, Concurrent World!
Processes, threads, and coroutines
Introduction to concurrency
Concurrency is not parallelism
CPU-bound and I/O-bound
Why concurrency is often feared
Concurrency in Kotlin
Concepts and terminology
Summary
2
Coroutines in Action
Coroutines in Action
Downloading and installing Android Studio
Creating a Kotlin project
Adding support for coroutines
Android's UI thread
Creating a thread
Adding networking permissions
Creating a coroutine to call a service
Adding UI elements
Displaying the amount of news that were processed
Using a UI dispatcher
Creating an asynchronous function to hold the request... or not
Summary
3
Life Cycle and Error Handling
Life Cycle and Error Handling
Job and Deferred
States move in one direction only
RSS – Reading from multiple feeds concurrently
Non-happy path – Unexpected crash
Summary
4
Suspending Functions and the Coroutine Context
Suspending Functions and the Coroutine Context
Improving the UI of the RSS Reader
Suspending functions
The coroutine context
More about contexts
Summary
5
Iterators, Sequences, and Producers
Iterators, Sequences, and Producers
Suspendable sequences and iterators
Iterators
Sequences
Suspending Fibonacci
Producers
Producers in action
Summary
6
Channels - Share Memory by Communicating
Channels - Share Memory by Communicating
Understanding channels
Types of channels and backpressure
Interacting with channels
Channels in action
Summary
7
Thread Confinement, Actors, and Mutexes
Thread Confinement, Actors, and Mutexes
Atomicity violation
Thread confinement
Actors
Mutual exclusions
Volatile variables
Atomic data structures
Actors in action
Summary
8
Testing and Debugging Concurrent Code
Testing and Debugging Concurrent Code
Testing concurrent code
Writing the tests
Debugging
Resiliency and stability
Summary
9
The Internals of Concurrency in Kotlin
The Internals of Concurrency in Kotlin
Continuation Passing Style
Context switching
Summary
10
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Producers

As we discussed previously, there is a limitation in both sequences and iterators: they can't suspend during execution. This is a big limitation for many use cases, because often what would be ideal is to be able to suspend while waiting for other operations to complete.

To overcome this limitation, we have to use producers. Their philosophy and usage are close to the ones of suspending sequences and iterators, but with a few small differences. The following are some important details on producers:

  • A producer suspends after a value is produced, and resumes when a new value is requested – similar to suspending sequences and iterators
  • A producer can be built with a specific CoroutineContext
  • The body of the suspending lambda that is passed can suspend at any point
  • Because it can suspend at any point, a value from a producer can only be received in a suspending...
Previous Section
End of Section 6
Next Section