Coroutines

HOW TO SAY GOODBYE TO THREADING
AND CALLBACK HELL
KOTLIN COROUTINES ON ANDROID
Sevil Guler - 12.04.2019

Sevil Güler
Senior Android Developer
Normal
Kotlin & Java
CI & CD

COROUTINES - KOTLIN 1.3

WHAT IS THE PROBLEM
progress.visibility = View.VISIBLE
userService.doLoginAsync(username, password) { user ->
userService.requestCurrentFriendsAsync(user) { friends ->
val finalUser = user.copy(friends = friends)
toast("User ${finalUser.name} has ${finalUser.friends.size} friends")
progress.visibility = View.GONE
}
}

WHAT IS THE PROBLEM
1. Do the second friends request after the ﬁrst one
2. Run both requests at the same time and ﬁnd a way to synchronize the callback results.

WHAT IS THE PROBLEM
userService.doLoginAsync(username, password) { user ->
userService.requestCurrentFriendsAsync(user) { currentFriends ->
userService.requestSuggestedFriendsAsync(user) { suggestedFriends ->
val finalUser = user.copy(friends = currentFriends + suggestedFriends)
}
}
}

WHAT ARE COROUTINES?
▸ Like threads but better
▸ asynchronous code sequentially
▸ can be run using the same thread
▸ light-weight
▸ the limit is almost inﬁnite.
▸ Based on the idea of suspending functions
▸ Safe place where suspending functions will not block the current
thread.

fun withCoroutines() = runBlocking {
repeat(100000) { counter ->
launch {
print(" $counter")
}
}
}
fun withThread() = runBlocking {
thread {
print(" $counter")
}
}
}

coroutine {
val user = suspended { userService.doLogin(username, password) }
val currentFriends = suspended { userService.requestCurrentFriends(user) }
val finalUser = user.copy(friends = currentFriends)
}
Coroutine builder

SUSPENDING FUNCTIONS
▸ Block the execution of the coroutine
val currentFriends = suspended { userService.requestCurrentFriends(user) }   
▸ Can run on the same or a different thread
▸ Only run inside a coroutine or inside another suspending
function.
▸ suspend reserved word

SUSPENDING FUNCTIONS
suspend fun suspendingFunction() : Int {
// Long running task
return 0
}
coroutine {
….
}
PROBLEM

COROUTINE CONTEXT
▸ Set of rules and conﬁgurations
▸ Dispatcher
✴ Explicitly: we manually set the dispatcher that will be used
✴ By the coroutine scope

EXPLICITLY
coroutine(Dispatchers.Main) {
}

PROBLEM
...
val currentFriends = suspended { userService.requestCurrentFriends(user) }
…
}

WITHCONTEXT
suspend fun suspendedLgn(name,passwrd) = withContext(Dispatchers.IO){
userService.doLogin(.., ..)
}
val user = withContext(Dispatchers.IO) { userService.doLogin(username, password) }
val currentFriends = withContext(Dispatchers.IO){ userService.requestCurrentFriends(user) }
}

DISPATCHERS
▸ Thread or Threads
▸ 1 thread can run multiple coroutines

DISPATCHERS
▸ Dispatcher.Default
▸ Dispatcher.IO
▸ Dispatcher.Unconﬁned
▸ Dispatcher.Main

HOW TO RUN COROUTINES - COROUTINES BUILDER
▸ runBlocking
▸ blocks the current thread  
▸ very helpful to test suspending tasks  
fun testSuspendingFunction() = runBlocking {
val res = suspendingTask1()
assertEquals(0, res)
}

HOW TO RUN COROUTINES - COROUTINES BUILDER
LAUNCH
GlobalScope.launch {
…..
}
▸ launch
▸ main builder
▸ won’t block the current thread
▸ always needs a scope
▸ returns a Job

JOBS HAVE A COUPLE OF INTERESTING FUNCTIONS
▸ job.join
▸ job.cancel
val job = GlobalScope.launch(Dispatchers.Main) {
doCoroutineTask()
val res1 = suspendingTask1()
val res2 = suspendingTask2()
process(res1, res2)
}
job.join()

ASYNC
GlobalScope.launch(Dispatchers.Main) {
val currentFriends = withContext(Dispatchers.IO{ userService.requestCurrentFriends(user) }
val suggestedFriends = withContext(Dispatchers.IO { userService.requestSuggestedFriends(user) }
val ﬁnalUser = user.copy(friends = currentFriends + suggestedFriends)
}

ASYNC
GlobalScope.launch(Dispatchers.Main) {
val currentFriends = async(Dispatchers.IO) { userService.requestCurrentFriends(user) }
val suggestedFriends = async(Dispatchers.IO) { userService.requestSuggestedFriends(user) }
val ﬁnalUser =currentFriends.await()+ suggestedFriends.await()
}

ASYNC
▸ several background tasks in parallel
▸ not a suspending function itself
▸ returns a specialized job that is called Deferred
▸ await(), which is the blocking one

SCOPES
▸ Global scope
▸ Implement CoroutineScope

GLOBAL SCOPE
GlobalScope.launch {
…..
}
▸ App lifecycle
▸ Think twice
▸ speciﬁc screen or component

IMPLEMENT COROUTINESCOPE
▸ override the coroutineContext
▸ conﬁgure: the dispatcher, and the job
▸ to identify the default dispatcher that the
coroutines will use
▸ cancel all pending coroutines at any moment
▸ plus(+) operation -> CombinedContext
the job is used as the parent of the coroutines created from this scope.
Dispatchers.Main + Dispatchers.IO == Dispatchers.IO

IMPLEMENT COROUTINESCOPE
class MainActivity : AppCompatActivity(), CoroutineScope {
private lateinit var job : Job
override val coroutineContext: CoroutineContext
get() = job + Dispatchers.Main
override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
super.onCreate(savedInstanceState, persistentState)
job = Job()
}
override fun onDestroy() {
super.onDestroy()
job.cancel()
}
}

COROUTINE CANCELATION
val job = launch {
try {
print(" $counter")
delay(50L)
}
} catch (e: CancellationException) {
print(" CancellationExceptionn")
}
}
delay(1000L)
job.cancel()
job.join()

EXCEPTIONS
▸ An exception other than CancellationException in a coroutine
scope cancels its parent.
▸ CoroutineExceptionHandler
val handler = CoroutineExceptionHandler { _, exception ->
println("Caught $exception")
}
▸ If we want cancellation to be propagated only downwards we can
use SupervisorJob or supervisorScope.

EXCEPTIONS
fun main() = runBlocking {
val handler = CoroutineExceptionHandler { _, exception ->
println("Caught $exception with suppressed ${exception.suppressed.contentToString()}")
}
val job = GlobalScope.launch(handler) {
launch {
try {
delay(Long.MAX_VALUE)
} finally {
throw ArithmeticException()
}
}
launch {
delay(100)
throw IOException()
}
}
job.join()
}
Caught java.io.IOException with suppressed [java.lang.ArithmeticException]

EXCEPTIONS
val supervisor = SupervisorJob()
with(CoroutineScope(supervisor)) {
val child1 = launch(handler) {
println("Child1 is failing")
throw AssertionError("child1 cancelled")
}
val child2 = launch {
child1.join()
println("Child1 cancelled: ${child1.isCancelled}")
println("Child2 isActive: $isActive")
try {
} finally {
println("Finally Child2 isActive: $isActive")
}
}
child1.join()
println("Cancelling supervisor")
supervisor.cancel()
child2.join()
}
Child1 is failing
Caught java.lang.AssertionError: child1 cancelled
Cancelling supervisor
Child1 cancelled: true
Child2 isActive: true
Finally Child2 isActive: false

WHAT IS NEXT?
▸ Channels
▸ Shared mutable state and concurrency
▸ Reactive streams with coroutines
….

Coroutines

Recommended

Recommended

More Related Content

Similar to Coroutines

Similar to Coroutines (20)

Recently uploaded

Recently uploaded (20)

Coroutines