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

Atomicity violation

As mentioned in the first chapter, there is a type of concurrency error called atomicity violation. This type of error happens when the state of an object is modified concurrently without correct synchronization. The example that we saw in the first chapter was pretty simple: many coroutines modified the state of an object from different threads, and this resulted in some of those modifications being lost.

This type of error can happen with Kotlin too, but the language offers primitives that will help you to use the right design so that you avoid atomicity violation.

First, we need to truly understand what atomicity means and how violations can happen. Then we will be able to understand how to write our code to make it run atomically.

What atomicity means

...
Previous Section
End of Section 2
Next Section