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
Mr. Jomar Tigcal
Jul, 2022 | 164 pages
Small book image
Kotlin Design Patterns and Best Practices
Alexey Soshin
Apr, 2024 | 474 pages
Small book image
Learn Kotlin Programming
Stephen Samuel | Stefan Bocutiu
May, 2019 | 514 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

The Internals of Concurrency in Kotlin

It's important that you have an idea of how suspending computations actually work. In this chapter, we will analyze how compiler transforms suspending functions into state machines, how the thread switching happens, and how exceptions are propagated. Some things that will be covered in this chapter are listed here:

  • Continuation Passing Style (CPS) and how it's related to suspending computations
  • Many different internal classes that are used when the coroutines are compiled into bytecode
  • The Flow of interception of a coroutine, including how threads are switched
  • Exception propagation with and without a CoroutineExceptionHandler

During the early sections of this chapter, we will be transforming a suspending function, imitating the work that the compiler does. Please notice that the code we write will not match the bytecode generated...

Previous Section
End of Section 1
Next Section