Kotlin Coroutines Entendendo o Conceito

Coroutines são uma ótima forma de escrever código assíncrono de um jeito muito simples e fácil, tanto para ler quanto manter. Nesta palestra irei abordar os conceitos básicos de Coroutines e Suspend Functions explicando sua abordagem por meio de exemplos de código. Não será uma palestra aprofundada em conceitos muito avançados. O objetivo será compartilhar de forma geral o conceito, e o entendimento do motivo dessa ferramenta do Kotlin estar ganhando tanto espaço no mundo de desenvolvimento atual.

Transcript

1. 1 Kotlin Coroutines Entendendo o Conceito Angélica Oliveira
2. ANGÉLICA OLIVEIRA MOBILE DEVELOPER @THOUGHTWORKS 2 LinkedIn: angelica-oliv
3. Sobre o que vamos falar? - Por que Coroutines? - Coroutine Builders - Suspending Functions - Coroutine Context e Dispatchers - Testes com Coroutines 3
4. Por que Coroutines? 4
5. COROUTINE BUILDERS 5
6. Coroutines Builders runBlocking 6 fun main() { println("Hello,") // block the main thread runBlocking { // now we are inside a coroutine delay(2000L) // suspends for 2 seconds } // will be executed after 2 seconds println("Coroutines!") }
7. Coroutines Builders launch 7 fun main() { GlobalScope.launch { // launch new coroutine in background and continue delay(1000L) println("Coroutines!") } println("Hello,") // main thread continues here immediately runBlocking { delay(2000L) // ... 2 seconds to keep JVM alive } }
8. Coroutines Builders async 8 fun main() { val deferredResult: Deferred<String> = GlobalScope.async { // suspend for 1 second delay(1000L) // this is the result "Coroutine!" } runBlocking { println("Hello") // wait for the result println(deferredResult.await()) } }
9. SUSPENDING FUNCTIONS 9
10. Suspending Functions Blocking x Suspending 10
11. Suspending Functions Blocking x Suspending 11
12. Suspending Functions Por default coroutines são sequenciais 12 private suspend fun doSomethingUsefulOne(): Int { delay(1000L) // pretend we are doing something useful here return 13 } private suspend fun doSomethingUsefulTwo(): Int { delay(1000L) // pretend we are doing something useful here, too return 29 }
13. Suspending Functions Por default coroutines são sequenciais 13 fun main() = runBlocking { val time = measureTimeMillis { val one = doSomethingUsefulOne() val two = doSomethingUsefulTwo() println("The answer is ${one + two}") } println("Completed in $time ms") } The answer is 42 Completed in 2014 ms
14. Suspending Functions Por default coroutines são sequenciais 14 fun main() = runBlocking { val time = measureTimeMillis { val one = async { doSomethingUsefulOne() } val two = async { doSomethingUsefulTwo() } println("The answer is ${one.await() + two.await()}") } println("Completed in $time ms") } The answer is 42 Completed in 1020 ms
15. COROUTINE CONTEXT E DISPATCHERS 15
16. - Coroutines sempre executam em um determinado contexto definido pelo tipo CoroutineContext - O contexto da Coroutine é um conjunto de vários elementos, os principais são: - Job - Dispatcher 16 Coroutines Context
17. - Jobs são executáveis que possuem um ciclo de vida - Podem possuir uma hierarquia parent-child - Os estados de um Job são definidos pelas flags: - isActive - isCompleted - isCancelled 17 Coroutines Context Job
18. 18 Coroutines Context Job
19. - Responsável por determinar que Thread ou Threads a Coroutine usa para sua execução - Todos os builders de Coroutine aceitam um CoroutineContext como parâmetro, para explicitamente especificar o Dispatcher e outros elementos do contexto 19 Coroutines Context Dispatcher
20. launch { ... } launch(Dispatchers.Unconfined) { ... } launch(Dispatchers.Default) { ... } launch(newSingleThreadContext("MyOwnThread")) { ... } 20 Coroutines Context Dispatcher Unconfined : I'm working in thread main Default : I'm working in thread DefaultDispatcher-worker-2 newSingleThreadContext: I'm working in thread MyOwnThread main runBlocking : I'm working in thread main
21. COROUTINES SCOPE 21
22. Coroutines Scope Global Scope 22 fun main() = runBlocking { GlobalScope.launch { repeat(1000) { i -> println("I'm sleeping $i ...") delay(500L) } } delay(1300L) // just quit after delay } I'm sleeping 0 ... I'm sleeping 1 ... I'm sleeping 2 ...
23. Coroutines Scope Scope builder 23 fun main() = runBlocking { // this: CoroutineScope coroutineScope { // Creates a coroutine scope launch { delay(500L) println("Task from nested launch") } delay(100L) println("Task from coroutine scope") } }
24. COROUTINES TESTS 24
25. - Chamada que sobrescreve o Main Dispatcher em situações de testes - Pode ser utilizado quando: - Main dispatcher não está disponível - É necessário sobrescrever por questões de sincronia dos testes (com uma implementação de um Dispatcher na classe de testes) 25 Coroutines Tests Dispatcher.setMain
26. // overrides Main Dispatcher with a test implementation Dispatchers.setMain(dispatcherImplementation) // reset Main Dispatcher with original implementation Dispatchers.resetMain() 26 Coroutines Tests Dispatcher.setMain
27. Provê controle extra para testar as coroutines: - Avanço do tempo automático para suspend functions - Avanço do tempo manual para testar coroutines múltiplas - Execução pausada de chamadas async e launch - Pausa, avanço ou recomeço das coroutines em um teste - Reportar exceções como falhas de testes 27 Coroutines Tests runBlockingTest
28. - TestCoroutineScope provê controle detalhado da execução das coroutines nos testes - TestCoroutineDispatcher é o dispatcher utilizado quando se executa uma coroutine com TestCoroutineScope - Ambos se integram com runBlockingTest 28 Coroutines Tests TestCoroutineScope e TestCoroutineDispatcher
29. CÓDIGO UTILIZADO NA PALESTRA ;) https://github.com/angelica-oliv/coroutines-basics 29
30. http://bit.ly/tw-tdcsp-vagas Quer se tornar uma ThoughtWorker? /careers
31. PERGUNTAS? 31
32. OBRIGADA 32 ANGÉLICA OLIVEIRA SENIOR CONSULTANT DEVELOPER angelica.deoliveira@thoughtworks.com | thoughtworks.com