9. Programação assíncrona com corrotinas
O capítulo anterior apresentou as threads: é possível executar vários trechos de código “ao mesmo tempo”, sincronizá-los e atribuir tarefas a um pool de threads por meio de um executor ([ExecutorService]). Este capítulo trata de um problema relacionado, mas distinto: como escrever um programa que espera muito (pelo disco, pela rede ou por um banco de dados) sem prender threads durante essas esperas.
Este é o capítulo em que o Kotlin mais se afasta do Java. O curso de Java apresentou duas soluções: a classe [CompletableFuture<T>], cujo comportamento é estendido por meio de métodos de callback, e as threads virtuais do Java 21, que permitem escrever código bloqueante sem bloquear nenhuma thread do sistema. Ambas as ferramentas continuam disponíveis em Kotlin (são classes do JDK) e voltaremos a elas. Mas o Kotlin oferece uma solução própria: as corrotinas:
- a linguagem inclui apenas uma única palavra-chave, [suspend], que marca uma função de suspensão: uma função que pode fazer uma pausa no meio de sua execução, liberar a thread que a executa e retomar mais tarde no mesmo ponto, com os mesmos valores de variáveis locais;
- o compilador transforma cada função de suspensão em uma “máquina de estados” capaz de pausar e retomar; veremos como;
- Todo o resto é fornecido por uma biblioteca, kotlinx.coroutines: iniciar corrotinas ([launch], [async]), esperar por elas ([join], [await]), esperar sem bloquear ([delay]), escolher as threads que as executam (os dispatchers), cancelá-las, limitar sua duração e passar valores entre elas ([Flow], [Channel]).
O código resultante é lido de cima para baixo como um código sequencial: é equivalente às palavras-chave do C# [async] / [await], com as quais os leitores do curso original estão familiarizados, mais um conceito que nem o C# nem o Java (exceto de forma preliminar) oferecem: a concorrência estruturada, que organiza as corrotinas em uma árvore em que cada nó espera por seus filhos, os cancela e recebe seus erros.
As corrotinas são hoje onipresentes no ecossistema Kotlin: no Android, em frameworks web (Ktor, Spring, que aceita funções [suspend] em seus controllers), em clientes HTTP e em drivers de banco de dados. Os próximos capítulos as usarão para acessar bancos de dados e a rede.
A biblioteca kotlinx.coroutines não faz parte da biblioteca padrão: o projeto Gradle deste capítulo, localizado na pasta [09-async], a declara em seu arquivo [build.gradle.kts]:
- linha 17: a dependência da biblioteca kotlinx.coroutines, versão 1.11.0. O pacote principal é [kotlinx.coroutines];
- linhas 32–34: como nos capítulos anteriores, o programa a ser executado é identificado pela propriedade [main]: [gradlew -q run -Pmain=async01.Async01Kt];
- linhas 42–45: os programas iniciados pelo Gradle escrevem sua saída em UTF-8 para que os caracteres acentuados sejam exibidos corretamente no Windows (Capítulo 2).
Os programas deste capítulo são organizados, como de costume, em pacotes com o nome deles: [src/main/kotlin/async01/Async01.kt], [src/main/kotlin/async02/Async02.kt]… Muitos deles medem durações usando [System.nanoTime()]: os milissegundos exibidos variam de uma execução para outra e de uma máquina para outra (os exemplos foram executados em uma máquina com dois processadores). O que importa são as ordens de grandeza: 1 segundo ou 10 segundos, 300 ms ou 0 ms. O primeiro uso de corrotinas em um programa carrega as classes da biblioteca, o que muitas vezes acrescenta algumas dezenas de milissegundos às primeiras medições.
9.1. Por que a assincronia
9.1.1. Operações que esperam
Um programa realiza dois tipos de trabalho:
- tarefas de cálculo, que ocupam o processador: ordenar uma lista, calcular um imposto, analisar um texto;
- entrada/saída (E/S), que consiste essencialmente em esperar por um dispositivo: ler um arquivo do disco, enviar uma requisição a um servidor web e esperar pela resposta, executar uma consulta SQL em um servidor de banco de dados.
As ordens de grandeza são muito diferentes. Um processador executa alguns bilhões de instruções por segundo. Uma operação de leitura em um disco (SSD) leva da ordem de um décimo de milissegundo; uma viagem de ida e volta em uma rede local leva uma fração de milissegundo; uma viagem de ida e volta a um servidor situado do outro lado do país leva algumas dezenas de milissegundos; e uma requisição SQL um pouco complexa pode às vezes levar vários segundos. Durante essas esperas, o processador poderia ter executado milhões de instruções.
Quando um programa lê uma linha em uma conexão de rede usando uma função bloqueante, a thread que executa essa leitura fica bloqueada: ela não faz nada, mas continua existindo. Uma thread “clássica” da JVM, agora chamada de “thread de plataforma”, é uma thread do sistema operacional: ela ocupa memória (sua pilha, da ordem de um megabyte), é reconhecida pelo sistema e, principalmente, deixa de estar disponível para fazer qualquer outra coisa. Isso não é um problema em um pequeno programa de console que faz uma coisa de cada vez. Mas é bem mais problemático em duas situações:
- em um servidor: cada cliente atendido por uma thread bloqueada prende essa thread. Se o pool de threads do servidor tem N threads e todas as N estão executando uma operação bloqueante, não resta nenhuma thread disponível para um novo cliente. Um servidor moderno atende milhares de requisições simultâneas: isso é possível porque suas operações de espera não prendem threads do sistema;
- em uma interface gráfica de usuário: uma única thread, a thread da interface (a thread principal de um aplicativo Android, a “Event Dispatch Thread” do Swing, a “JavaFX Application Thread”), trata os cliques e redesenha as janelas. Se ela for bloqueada por um download, a janela congela; no Android, o sistema chega até a propor ao usuário que feche o aplicativo.
A assincronia consiste em iniciar a operação de E/S, liberar a thread do sistema enquanto ela é executada (o hardware e o sistema operacional não precisam dela para transferir os dados) e depois retomar o trabalho quando a operação terminar, possivelmente em outra thread. As threads virtuais do Java fazem isso no nível da JVM: uma thread virtual bloqueada é desvinculada de sua thread hospedeira, que, nesse meio-tempo, continua executando outras threads virtuais. As corrotinas do Kotlin fazem isso no nível do código compilado: uma corrotina em espera é suspensa, ou seja, seu estado (o ponto em que parou e suas variáveis locais) é armazenado em um objeto do heap chamado continuação, e a thread que a executava é devolvida ao seu pool:

- Em [1], a thread do sistema T1 executa uma função bloqueante; ela permanece bloqueada até que a E/S termine;
- Em [2], a corrotina C1 chama uma função de suspensão que inicia a E/S; a corrotina é suspensa: sua continuação é armazenada no heap, e a thread T1 que a executava pode executar imediatamente outras corrotinas. Quando a E/S termina, a continuação é retomada por uma thread livre, T2 (que também poderia ser T1), e C1 prossegue sua execução logo após a chamada da função de suspensão, como se nada tivesse acontecido.
O programa [Async01.kt] mede a diferença em 100 operações, cada uma das quais espera um segundo (a espera simula uma E/S). Ele usa instruções que explicaremos mais adiante neste capítulo ([runBlocking], [launch], [delay]): aqui, o que nos interessa primeiro são os resultados.
Resultados:
Comentários:
- Linhas 19–25: a solução mais simples, uma thread de plataforma por operação. A função [thread { … }] de [kotlin.concurrent] (Capítulo 8) cria e inicia uma thread; [List(NB_OPERATIONS) { … }] constrói a lista de 100 threads. Cada thread executa [Thread.sleep(1000)]: ela fica bloqueada por um segundo. As 100 esperas ocorrem simultaneamente, e o processo inteiro leva exatamente um segundo (linha 4 dos resultados), mas ao custo de 100 threads de sistema adicionais: a JVM contabiliza 106 (linha 3). Com 10.000 operações, seriam necessárias 10.000 threads de sistema;
- Linhas 27–34: as operações são atribuídas a um pool de 10 threads ([Executors.newFixedThreadPool(10)]), um tamanho razoável para cálculos. Mas aqui essas threads não fazem cálculos: ficam ociosas. As operações esperam uma thread livre, em lotes de 10, e o processo inteiro leva… dez segundos (linha 6). É o que se chama de “inanição do pool de threads”, o defeito mais comum em servidores que misturam pools de threads com E/S bloqueante. Um [ExecutorService] é [AutoCloseable] (Java 19): a função [use] chama seu método [close()] ao fim do bloco, que rejeita novas tarefas e espera as que já foram submetidas terminarem ([use] desempenha o mesmo papel que [try] com um recurso em Java);
- linhas 36–43: uma thread virtual por operação. O código da tarefa é o mesmo do passo 1: um [Thread.sleep(1000)]bloqueante. No entanto, uma thread virtual bloqueada não bloqueia nenhuma thread do sistema. As 100 esperas juntas duram um segundo (linha 8), e a JVM tem apenas 10 threads de sistema (linha 7): suas threads de serviço e as duas threads portadoras, uma por processador. Esta é a solução do curso de Java;
- linhas 45–53: uma corrotina por operação. [runBlocking { … }] executa um bloco de código como uma corrotina na thread que o chama (aqui, a thread [main]), e só devolve o controle ao final dessa corrotina e de todas as que ela iniciou. Dentro do bloco, [launch { delay(1000) }] inicia uma nova corrotina que espera um segundo: [delay] é uma função de suspensão que suspende a corrotina sem bloquear a thread. As 100 corrotinas são executadas pela única thread [main]: enquanto elas esperam, ela não lhes deve nada e executa as outras. A JVM continua com 10 threads (linha 9): nenhuma a mais que no passo anterior. O processo inteiro leva pouco mais de um segundo (linha 10), e o tempo extra vem do carregamento das classes da biblioteca, que ocorre nesse primeiro uso;
- linha 50: para medir o número de threads na metade do caminho, a corrotina principal também espera com [delay]. Com [Thread.sleep], ela bloquearia a thread [main], que é a única que executa as 100 corrotinas: elas só poderiam começar quando essa espera terminasse. Voltaremos a essa diferença fundamental entre [delay] e [Thread.sleep];
- linhas 55–62: cem mil corrotinas, ainda executadas somente pela thread [main], sem nenhuma thread adicional (linha 11). Uma corrotina suspensa é simplesmente um pequeno conjunto de objetos no heap, cada um com algumas dezenas de bytes: pode haver centenas de milhares delas. Criar as 100.000 corrotinas e seus temporizadores já leva algum tempo (algumas centenas de milissegundos na máquina do exemplo, daí o tempo mostrado na linha 12); já criar 100.000 threads de plataforma seria simplesmente impossível na maioria das máquinas;
- linha 75: [ManagementFactory.getThreadMXBean().threadCount] retorna o número de threads de plataforma ativas da JVM. Em Kotlin, o método Java [getThreadCount()] é tratado como uma propriedade, [threadCount];
- A função [thread] e seus executores usam [Thread.sleep] diretamente: o Kotlin não tem exceções verificadas (Capítulo 3), de modo que não é preciso capturar a [InterruptedException] que [Thread.sleep] pode lançar, como fazia o método [waitFor] no programa Java.
Guardemos a lição: para esperar, não se deve bloquear nenhuma thread do sistema. A assincronia não torna a E/S mais rápida; ela permite tratar muitas operações de E/S simultaneamente com poucas threads e manter disponíveis as threads de que a aplicação precisa. O Kotlin oferece duas abordagens: escrever código bloqueante comum executado por threads virtuais (passo 3, como em Java) ou escrever funções de suspensão executadas por corrotinas (passos 4 e 5). Este capítulo se concentra na segunda abordagem.
9.1.2. Vários modelos sucessivos
As plataformas ofereceram várias maneiras de escrever código que espera sem bloquear. As mais antigas ainda são encontradas em códigos existentes, e o Kotlin, que usa diretamente as bibliotecas Java, convive com elas: é útil reconhecê-las.
Modelo | Surgimento | Princípio |
Threads e executores | Java 1.0 (1996), Java 5 (2004) | uma thread por operação ou um pool de threads ([ExecutorService]). [submit] retorna um [Future<T>], que representa o resultado futuro, mas a única maneira de obter esse resultado é esperar, de forma bloqueante, com [get()]. |
métodos de callback | Java 7 (NIO.2, 2011), JavaScript | uma operação é iniciada passando-lhe um objeto ou uma função de callback ([CompletionHandler] do NIO.2), que é chamada ao final da operação por uma thread de um pool. |
futures componíveis | Java 8 ([CompletableFuture], 2014), promises do JavaScript | um objeto que representa a operação em andamento e cujas etapas seguintes são compostas por meio de métodos ([thenApply], [thenCompose], [exceptionally]…); as bibliotecas reativas (Project Reactor, RxJava) baseiam-se nas mesmas ideias. |
[async] / [await] | C# 5 (2012), seguido por JavaScript, Python, Rust… | métodos [async] que retornam uma tarefa ([Task<T>] em C#); [await] suspende o método até que a tarefa termine, sem bloquear a thread. O compilador transforma o método em uma máquina de estados. |
Corrotinas do Kotlin | Kotlin 1.3 (2018) | Funções [suspend] são transformadas pelo compilador em máquinas de estados, e a biblioteca kotlinx.coroutines fornece a concorrência estruturada. As chamadas a funções de suspensão não incluem nenhuma palavra-chave: o código tem a forma de um código sequencial. |
Threads virtuais | Java 21 (2023) | Código bloqueante comum, executado por threads virtuais: a JVM libera a thread do sistema durante as esperas. |
Os métodos de callback têm um inconveniente: o código fica fragmentado. O que naturalmente se lê como “conectar, depois ler, depois exibir” se torna uma função que inicia a conexão, uma função de callback que inicia a leitura e outra função de callback que exibe os dados; as variáveis precisam ser compartilhadas entre essas funções, as exceções são capturadas em lugares diferentes, e um simples laço (“ler enquanto houver dados”) se torna uma função de callback que chama a si mesma recursivamente. Os futures componíveis tornam essa fragmentação mais legível ao encadear as etapas; as corrotinas a eliminam por completo: o código assíncrono tem a forma de um código síncrono. A diferença em relação às threads virtuais é que é o compilador, e não a JVM, que divide o código nos pontos de espera.
O programa [Async02.kt] implementa o mesmo cliente TCP usando os dois modelos extremos: primeiro com os métodos de callback do NIO.2 e depois com uma corrotina. Ele também contém um pequeno servidor, executado por uma thread, que responde a dois clientes (a programação de rede será tratada em detalhes no Capítulo 12; por ora, basta saber que um cliente se conecta ao servidor e lê a mensagem que o servidor lhe envia).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | |
Resultados:
Comentários:
- Linhas 23–36: o servidor. Ele escuta na porta 27500 da máquina local ([InetAddress.getLoopbackAddress()], isto é, 127.0.0.1), aceita duas conexões uma após a outra e envia a cada cliente uma mensagem de boas-vindas após meio segundo. Ele é executado por uma thread de plataforma chamada [server], criada pela função [thread] com o argumento nomeado [name]. As funções [use] fecham o [ServerSocket] e cada [Socket] de serviço ao final de seu bloco;
- linhas 38–71: o cliente escrito com métodos de callback:
- Linha 40: um [AsynchronousSocketChannel] é um canal TCP cujas operações são assíncronas;
- Linha 43: [connect] inicia a conexão e devolve imediatamente o controle (linha 3 dos resultados). Seus dois últimos parâmetros são um objeto arbitrário que o método de callback receberá (aqui, [Unit], pois não precisamos dele) e o objeto de callback, que implementa a interface [CompletionHandler<V, A>], em que [V] é o tipo do resultado da operação ([Void?] para uma conexão, que não retorna nada) e [A] é o tipo do objeto passado. O Kotlin permite criar esse objeto na hora com uma expressão de objeto ([object : CompletionHandler<Void?, Unit> { … }]), equivalente às classes anônimas do Java. Seu método [completed] é chamado se a operação for bem-sucedida, e seu método [failed] se ela falhar;
- linhas 44–48: depois de conectado, a leitura é iniciada com
*[read]*, especificando um segundo objeto de callback aninhado no primeiro; - linhas 49–54: o objeto de callback de leitura recebe o número de bytes lidos, exibe a mensagem, fecha o canal e libera a thread principal;
- linha 71: a thread principal não tem mais nada a fazer. Para garantir que o programa não termine antes do fim da troca, ela espera um sinal do último método de callback: um
*[CountDownLatch]inicializado com 1, cujo método*[await]*bloqueia a thread chamadora até que outra thread chame seu método*[countDown];
- os resultados mostram que os métodos de callback são executados por threads diferentes da thread principal (threads do pool da JVM dedicado aos canais assíncronos, chamadas [InnocuousThread-N]). O aninhamento dos dois objetos de callback já dificulta o acompanhamento do código; com três ou quatro operações sucessivas, chega-se ao que se chama de “callback hell”;
- linhas 73–88: o mesmo cliente escrito com uma corrotina iniciada por [runBlocking]. O código é lido de cima para baixo, exatamente como um código síncrono: conectar, ler, exibir. As variáveis são variáveis locais comuns; os erros são tratados por um único [try / catch]; não há objetos de callback aninhados nem sinais a gerenciar. No entanto, nenhuma thread espera pela conexão ou pela resposta do servidor: [connectTo] e [readInto] são funções de suspensão, que suspendem a corrotina durante a operação;
- linhas 92–99: a função [connectTo] converte a operação com callback em uma função de suspensão. Ela é uma função de extensão (Capítulo 4) de [AsynchronousSocketChannel], marcada com [suspend]. A função [suspendCancellableCoroutine] da kotlinx.coroutines suspende a corrotina que a chama e passa ao bloco a continuação dessa corrotina, isto é, o objeto que permite retomá-la. O bloco inicia a operação com um objeto de callback que, ao final da operação, retoma a corrotina: ou devolvendo um valor ([resume]) ou fazendo-a lançar uma exceção ([resumeWithException]). O método de callback não faz mais nada: toda a lógica do cliente permanece na corrotina;
- linhas 104–107: a operação de leitura, também convertida em uma função de suspensão que retorna o número de bytes lidos;
- o fim dos resultados mostra que a corrotina exibe na thread [main], tanto antes quanto depois das duas suspensões: o método de callback, executado por uma [InnocuousThread], retoma a continuação, mas esta é redirecionada para a thread [runBlocking]. Veremos na seção sobre dispatchers como é escolhida a thread que executa o restante de uma corrotina.
É importante compreender esse mecanismo, pois ele vale para todas as corrotinas: uma corrotina suspensa é uma continuação pendente, e uma continuação nada mais é que um método de callback, mas um que o próprio compilador gera a partir do restante do código. É raro precisar escrever você mesmo funções como [connectTo]: a biblioteca kotlinx.coroutines e outras bibliotecas Kotlin fornecem funções de suspensão para a maioria das operações. Mas, se você precisar usar uma API que só oferece métodos de callback, [suspendCancellableCoroutine] permite transformá-la em poucas linhas.
9.2. Operações futuras: CompletableFuture e Deferred
9.2.1. O CompletableFuture visto do Kotlin
Um [Future<T>] (interface do pacote [java.util.concurrent], Java 5) é um objeto que representa o resultado, do tipo [T], de uma operação em andamento ou já concluída. Já o encontramos no capítulo anterior: é isso que o método [submit] de um executor retorna. É possível consultá-lo (terminou? teve sucesso?), cancelá-lo ([cancel]) e esperar seu resultado ([get]), mas nada além disso: a única maneira de usar o resultado é bloquear uma thread até que ele esteja disponível.
A classe [CompletableFuture<T>] (Java 8) implementa [Future<T>] e acrescenta dois recursos essenciais:
- é possível concluí-lo você mesmo, seja com um resultado ([complete]), seja com uma exceção ([completeExceptionally]);
- é possível associar a ele uma etapa de processamento posterior, isto é, uma função que será executada quando o resultado estiver disponível ([thenApply], [thenAccept], [thenCompose]…), e que produz um novo [CompletableFuture]. Isso permite construir cadeias de operações sem que nenhuma thread precise esperar.
Um [CompletableFuture] não é uma thread. Ele pode representar um processamento executado por uma thread de um executor (como é o caso dos criados por [supplyAsync]), mas muitos não são executados por nenhuma thread: aquele retornado pelo método [sendAsync] do cliente HTTP do JDK é concluído quando a resposta do servidor chega. Ele é uma promessa de resultado.
Os programadores Kotlin encontram [CompletableFuture] toda vez que usam uma biblioteca Java assíncrona: o cliente HTTP do JDK, certos drivers de banco de dados, clientes de serviços de nuvem etc. Eles precisam saber lidar com eles e, acima de tudo, como ligá-los às corrotinas. O programa [Async03.kt] é uma versão Kotlin do programa Java que demonstrava as principais maneiras de criar, consultar e esperar um [CompletableFuture]:
Resultados:
Comentários:
- Linhas 10–17: [CompletableFuture.supplyAsync(supplier)] passa uma função sem parâmetros (um [Supplier<T>] do Java) a um executor e retorna imediatamente um [CompletableFuture<T>] que representa sua execução. Graças à conversão SAM (Capítulo 7), uma lambda do Kotlin é passada a ele, colocada fora dos parênteses; sua última expressão, [sum], é o resultado. Sem um executor explícito, é o pool compartilhado da JVM, [ForkJoinPool.commonPool()], que executa a função;
- linha 19: o método [state()] (Java 19) retorna o estado da operação: [RUNNING] (em andamento), [SUCCESS] (concluída com sucesso), [FAILED] (concluída com uma exceção) ou [CANCELLED] (cancelada). Essas são as constantes da enumeração [Future.State];
- linha 21: [join()] espera a operação terminar e retorna seu resultado. Trata-se de uma espera bloqueante: a thread atual fica suspensa (aqui, a thread principal, o que não atrapalha em um pequeno programa de console);
- linhas 24–28: um [CompletableFuture] criado “em andamento” pelo seu construtor e concluído por um temporizador após 300 ms ([completeOnTimeout], Java 9): é o equivalente assíncrono de [Thread.sleep(300)]. Em Java, uma operação sem resultado tem o tipo [CompletableFuture<Void>]; em Kotlin, é possível escrever [CompletableFuture<Unit>], cujo único valor é [Unit];
- linhas 30–34: [completedFuture(42)] retorna um [CompletableFuture] já concluído cujo resultado é 42, e [failedFuture(exception)] retorna um [CompletableFuture] que já falhou; o tipo do resultado deste último não pode ser inferido a partir de seu argumento, por isso é especificado entre colchetes angulares: [failedFuture<Int>(...)]. [resultNow()] e [exceptionNow()] (Java 19) retornam imediatamente o resultado ou a exceção de uma operação concluída, sem esperar;
- Linhas 36–41: uma operação cuja função lança uma exceção termina no estado [FAILED]. A exceção é armazenada no [CompletableFuture], e [join()] dispara uma [CompletionException] cuja causa ([cause], o método [getCause()] tratado como propriedade) é a exceção original, neste caso uma [NumberFormatException] lançada por ["abc".toInt()];
- linhas 44–48: [get()], o método herdado da interface [Future], também espera de forma bloqueante, mas encapsula a exceção em uma [ExecutionException]. Em Java, esta é uma exceção verificada, que o método [main] deveria capturar ou declarar, assim como a [InterruptedException] que [get()] pode lançar. O Kotlin não tem exceções verificadas: você intercepta apenas as que lhe interessam, e nada mais;
- linhas 51–56: a continuação. [f2.thenApply { 2 * 21 }] retorna um novo [CompletableFuture] que será concluído com o resultado da função quando [f2] for concluído: isso produz um [CompletableFuture<Int>]. [thenAccept] associa uma função que consome o resultado sem produzir outro e retorna um [CompletableFuture<Void>] (este é um método Java: seu tipo de retorno é [Void], que o Kotlin não transforma em [Unit]);
- linhas 58–60: os métodos booleanos [isDone()] (concluído, independentemente de como), [isCompletedExceptionally()] (concluído com uma exceção ou cancelado) e [isCancelled()] (cancelado): o Kotlin os representa como propriedades: [isDone], [isCompletedExceptionally] e [isCancelled].
O curso de Java dedicou então várias páginas à composição de [CompletableFuture]: [thenCompose], [thenCombine], [allOf], [anyOf], [exceptionally], [handle], [orTimeout]… Em Kotlin, quase nunca é preciso usar esses métodos: basta esperar o [CompletableFuture] em uma corrotina, com a função de suspensão [await()], e escrever o restante como código comum. A tabela a seguir compara os métodos de [CompletableFuture] com seus equivalentes em corrotinas (todas essas funções são tratadas neste capítulo):
[CompletableFuture] | corrotinas |
[supplyAsync(f)], [runAsync(r)] | [async { … }] (retorna um [Deferred<T>]), [launch { … }] (retorna um [Job]) |
[completedFuture(v)], [complete(v)] | um simples valor; [CompletableDeferred] para concluir uma operação manualmente |
[thenApply(f)], [thenAccept(c)], [thenRun(r)] | [val v = operation()] seguido do restante do código |
[thenCompose(f)] | duas chamadas consecutivas a funções de suspensão |
[thenCombine(other, f)], [allOf(...)] | [async], seguido de [await] e [awaitAll] |
[anyOf(...)] | [select] |
[exceptionally(f)], [handle(f)], [whenComplete(c)] | [try / catch / finally] |
[orTimeout(...)], [completeOnTimeout(...)] | [withTimeout], [withTimeoutOrNull] |
[cancel] | [cancel], que realmente encerra a operação (reversão cooperativa) |
[join()], [get()] | [await()], [join()]: esperas que suspendem a corrotina em vez de bloquear a thread |
9.2.2. Deferreds
O equivalente em corrotinas de um [CompletableFuture<T>] é a interface [Deferred<T>] (“diferido”) da kotlinx.coroutines: o resultado futuro de uma corrotina. Ele é obtido iniciando-se uma corrotina com a função [async] e esperando seu resultado com a função de suspensão [await()]. Um [Deferred<T>] é um caso particular de [Job], a interface que representa uma corrotina em execução ou já terminada, sem resultado; um *[Job]* é obtido iniciando-se uma corrotina com a função *[launch]*, e esperando seu término com a função de suspensão *[join()]*.
O programa [Async04.kt] demonstra o [Deferred], o [Job] e a passagem do primeiro para o [CompletableFuture] e vice-versa:
Resultados:
Comentários:
- Linha 17: a função [main] é uma expressão [runBlocking { … }]. O bloco é executado como uma corrotina pela thread [main], e [runBlocking] só devolve o controle ao final dessa corrotina. É dentro desse bloco que as funções de suspensão ([await], [delay]…) podem ser chamadas e outras corrotinas ([async], [launch]) podem ser iniciadas: o bloco recebe implicitamente um [CoroutineScope] (um escopo de corrotinas), do qual [async] e [launch] são funções de extensão. Voltaremos a isso na seção sobre concorrência estruturada;
- linhas 18–25: [async] inicia uma nova corrotina que executa o bloco e retorna imediatamente um [Deferred<Long>] que representa seu resultado (a última expressão do bloco). O parâmetro [Dispatchers.Default] faz a corrotina ser executada por um pool de threads dedicado a cálculos: sem ele, a corrotina seria executada pela thread de [runBlocking] e só começaria quando a corrotina principal fosse suspensa pela primeira vez;
- Linha 27: o estado de uma corrotina é determinado por três propriedades de [Job]: [isActive] (em andamento), [isCompleted] (concluída, independentemente de como) e [isCancelled] (cancelada ou com falha, como veremos adiante). A função [state] (linhas 74–75) as exibe;
- linha 29: [await()] espera a corrotina terminar e retorna seu resultado. Ao contrário de [join()] em um [CompletableFuture], essa espera não bloqueia a thread: é uma função de suspensão, que suspende a corrotina principal; enquanto isso, a thread [main] fica disponível para outras corrotinas;
- linhas 32–38: uma corrotina que espera 300 ms com
*[delay]* e depois retorna uma string: nenhuma thread fica ocupada durante a espera; - linhas 40–46: [launch] inicia uma corrotina que não retorna resultado e devolve um [Job]. [join()] suspende a corrotina principal até que essa corrotina termine. [launch] / [Job] estão para as corrotinas assim como [runAsync] / [CompletableFuture<Void>] estão para o mundo dos [CompletableFuture];
- Linhas 48–55: uma corrotina que falha. [await()] relança a exceção original, uma [NumberFormatException], sem encapsulá-la em outra exceção: ela é interceptada como se a chamada tivesse sido feita diretamente. O estado exibido mostra que um [Job] com falha tem [isCancelled=true]: para a kotlinx.coroutines, uma falha é uma forma de cancelamento. O bloco [supervisorScope] é necessário aqui por um motivo que veremos na seção sobre exceções: sem ele, a falha de uma corrotina se propagaria para a corrotina que a iniciou e teria encerrado o programa inteiro;
- Linhas 59–61: a função de extensão [CompletableFuture<T>.await()], do pacote [kotlinx.coroutines.future], espera um [CompletableFuture] suspendendo a corrotina, sem bloquear nenhuma thread. Ela serve de ponte entre as bibliotecas Java assíncronas e as corrotinas: uma chamada [client.sendAsync(request, handler).await()] espera a resposta de um servidor web, como veremos mais adiante neste capítulo. Se o [CompletableFuture] falhar, [await()] lança a exceção original, sem o encapsulamento em [CompletionException];
- linhas 63–65: inversamente, [asCompletableFuture()] apresenta um [Deferred] como um [CompletableFuture], por exemplo, para passá-lo a um código Java que não suporta corrotinas;
- linhas 66–71: a função [future { … }] inicia uma corrotina e retorna diretamente um [CompletableFuture]: é assim que se escreve, em Kotlin, usando corrotinas, um método assíncrono destinado a código Java. Na linha 71, esse
*[CompletableFuture]é composto com*[thenApply], e depois o resultado é aguardado com*[await()]*.
9.3. Funções de suspensão
9.3.1. suspend, launch, async e await
Em Kotlin, uma operação assíncrona é escrita como uma função de suspensão: uma função comum, declarada com o modificador *[suspend] , que retorna diretamente seu resultado (em vez de um *[CompletableFuture] ou de um *[Deferred]* que o representaria):
- [suspend fun makeCoffee()] para uma operação que não retorna resultado;
- [suspend fun countSugars(number: Int): Int] para uma operação que retorna um inteiro.
Uma função de suspensão pode chamar outras funções de suspensão, como [delay], [await] e [join], e é durante essas chamadas que ela pode ser suspensa. Ela só pode ser chamada por outra função de suspensão ou a partir de uma corrotina (o corpo de um [runBlocking], de um [launch] ou de um [async]); o compilador impõe isso. Essa é a única restrição: dentro dela, escreve-se código comum, com laços, [if], [try / catch] e variáveis locais.
Uma chamada a uma função de suspensão não inclui nenhuma palavra-chave: onde o C# escreve [await MakeCoffeeAsync()], o Kotlin escreve [makeCoffee()]. E essa chamada é sequencial: a linha seguinte só é executada depois que a função chamada termina. Para executar várias operações em paralelo, é preciso indicá-lo explicitamente, iniciando novas corrotinas com [launch] ou *[async]*. Essa é uma escolha deliberada dos projetistas do Kotlin: o código sequencial é a norma, portanto deve ser o mais simples de escrever; a concorrência deve ser explícita.
O tutorial de Java preparava café e contava cubos de açúcar, primeiro com [CompletableFuture] encadeados com [thenRun] e [thenCompose], depois com código bloqueante executado por threads virtuais. O programa [Async05.kt] prepara o mesmo café usando funções de suspensão:
Resultados:
Comentários:
- Linhas 34–41: uma operação sem resultado escrita como função comum: uma instrução de impressão, uma espera de um segundo, uma instrução de impressão, uma espera de meio segundo, uma instrução de impressão. [delay] é a função de suspensão da kotlinx.coroutines, que espera o atraso especificado (em milissegundos ou na forma de uma duração [kotlin.time.Duration]: [delay(1.seconds)]) suspendendo a corrotina. Isso equivale ao método [delay] do programa Java, que retornava um [CompletableFuture] concluído por um temporizador; mas aqui o restante da função não precisa ser escrito em uma continuação: ele simplesmente segue a chamada;
- linhas 44–50: uma operação que retorna um inteiro. O laço é um laço de verdade, que espera a cada iteração: essa é a única diferença em relação à versão Java com [CompletableFuture], em que o laço construía uma cadeia de [thenCompose] em vez de executar iterações (e em que era necessária uma variável [number], cópia de [i], para a lambda);
- linha 16: [launch] inicia uma nova corrotina que executa [makeCoffee()] e retorna imediatamente um [Job];
- linha 19: [async] inicia uma nova corrotina que executa [countSugars(3)] e retorna imediatamente um [Deferred<Int>];
- linhas 22–23: a corrotina principal espera as duas operações; ela fica suspensa durante essas esperas;
- As linhas 2 a 12 da saída mostram a execução: o café fica pronto após 1,5 segundo, a duração da mais longa das duas operações, e os sachês de açúcar foram contados enquanto a máquina esquentava. Mas elas também mostram uma diferença em relação aos programas Java: a máquina só começa a esquentar (linha 6) depois da última instrução de impressão do programa principal (linha 5). Todas as corrotinas do programa são executadas por uma única thread, [main], que pertence a [runBlocking]: [launch] e [async] não executam imediatamente a corrotina que criam; em vez disso, colocam-na na fila da thread, que a executará quando ficar livre, isto é, quando a corrotina principal se suspender (linha 22). Isso se chama multitarefa cooperativa: uma corrotina mantém a thread até se suspender;
- linhas 26–31: as mesmas funções chamadas diretamente, sem iniciar uma corrotina. Cada chamada termina antes que a seguinte comece: o café é preparado (1,5 segundo) e depois os cubos de açúcar são contados (0,6 segundo), num total de 2,1 segundos (linhas 13–20 dos resultados). Essa é a abordagem correta quando uma operação depende do resultado da anterior;
- linha 54: cada saída mostra o tempo decorrido e a thread que a executa: é sempre [main].
Vemos a mesma qualidade da versão Java com threads virtuais: as funções são funções comuns, que se leem de cima para baixo; a decisão de executá-las sequencialmente (chamada direta) ou concorrentemente ([launch], [async]) é tomada no momento da chamada. No entanto, ao contrário das threads virtuais, uma única thread bastou para o programa inteiro, e não foi a JVM que liberou a thread durante as esperas: foram as próprias funções de suspensão.
9.3.2. delay e Thread.sleep
Uma corrotina libera sua thread somente quando se suspende, isto é, quando chama uma função de suspensão que está esperando. Se ela chamar uma função bloqueante ([Thread.sleep], uma leitura de arquivo ou de socket com as classes de [java.io], uma requisição JDBC…), ela bloqueia a thread que a executa, e todas as corrotinas que dependem dessa thread ficam em espera. O programa [Async06.kt] ilustra a diferença:
Resultados:
Comentários:
- Linhas 12–18: duas corrotinas iniciadas em um
*[runBlocking], cada uma das quais executa três etapas separadas por*[delay(100)]*. Elas compartilham a thread*[main]: enquanto uma espera, a outra trabalha; as etapas se alternam (A1, B1, A2, B2…) e os períodos de espera das duas corrotinas se sobrepõem: o processo inteiro leva cerca de 300 ms, mais o tempo de carregamento das classes da biblioteca nesse primeiro uso (linha 8 dos resultados). A função [runBlocking] só devolve o controle quando as duas corrotinas que ela iniciou terminam: não é preciso escrever código para esperá-las; - linhas 20–26: as mesmas corrotinas, esperando com [Thread.sleep]. Cada espera bloqueia a única thread [main]: a corrotina B só pode começar depois que A termina, e o processo inteiro leva 600 ms (linhas 9–15). As duas corrotinas deixam de ser verdadeiramente corrotinas: elas se executam uma após a outra;
- linhas 28–34: as corrotinas que contêm código bloqueante são repassadas a outro grupo de threads, o dispatcher [Dispatchers.IO], passando-o como parâmetro a [launch]. Cada uma bloqueia então sua própria thread; elas rodam simultaneamente, e o processo inteiro volta a levar 300 ms (linhas 16–22). Esta é a abordagem padrão quando é preciso chamar código bloqueante a partir de corrotinas (como uma biblioteca que não oferece funções de suspensão, por exemplo, o JDBC); mas isso acarreta o custo de uma thread de sistema por operação em andamento. As threads desse dispatcher se chamam [DefaultDispatcher-worker-N]: veremos o motivo na seção sobre dispatchers;
- linhas 37–41: [workWithDelay] chama [delay]: esta é uma função de suspensão;
- linhas 45–49: [workWithSleep] não chama nenhuma função de suspensão: é uma função comum. O compilador permite que ela seja chamada a partir de uma corrotina, mas o IntelliJ e o IDEA sinalizam as chamadas a funções bloqueantes conhecidas ([Thread.sleep], as operações de E/S de [java.io]) colocadas dentro de uma função de suspensão ou de uma corrotina (“Possibly blocking call in non-blocking context”).
Daí a primeira regra da programação com corrotinas: uma função de suspensão nunca deve bloquear sua thread. Se precisar chamar código bloqueante, ela o delega a um dispatcher concebido para isso ([Dispatchers.IO], ou um dispatcher baseado em threads virtuais), com [withContext], que veremos em breve.
9.3.3. O que o compilador faz: continuações e máquinas de estados
Como uma função de suspensão consegue fazer uma pausa no meio de um laço, liberar sua thread e depois retomar mais tarde no mesmo ponto, com os mesmos valores de variáveis locais, possivelmente em outra thread? O curso de Java explicou que, para uma thread virtual, é a JVM que faz esse trabalho: ela copia a pilha de chamadas da thread virtual para o heap e a restaura ali mais tarde. A JVM não sabe nada sobre as corrotinas do Kotlin: quem faz o trabalho é o compilador , transformando cada função de suspensão. Ele o faz em duas etapas.
Primeira etapa: a continuação se torna um parâmetro. Cada função [suspend] recebe, no bytecode, um parâmetro adicional do tipo [Continuation<T>] (uma interface do pacote [kotlin.coroutines] da biblioteca padrão), em que [T] é o tipo do valor de retorno da função. Uma continuação representa “a próxima etapa do cálculo”: o que fazer com o resultado da função. Ela tem um método [resumeWith(result)], que retoma a execução com um resultado ou uma exceção (as funções de extensão [resume(value)] e [resumeWithException(e)] o chamam), e uma propriedade [context], o contexto da corrotina (voltaremos a isso). O tipo de retorno da função se torna [Any?] ([Object] na JVM): a função retorna ou seu resultado, se conseguiu terminar sem esperar, ou um valor especial, [COROUTINE_SUSPENDED], que significa “estou suspensa; minha continuação será retomada mais tarde”. Este é o “estilo de passagem de continuação” (CPS, continuation-passing style).
Segunda etapa: o corpo da função se torna uma máquina de estados. Cada chamada a uma função de suspensão dentro do corpo é um potencial ponto de suspensão. O compilador numera esses pontos (o número é chamado de [label]) e armazena o número do próximo ponto de retomada e as variáveis locais que precisam sobreviver a uma suspensão em um objeto de continuação específico da função. O corpo da função se torna um [when] sobre esse número: ele é executado uma vez no início (label 0) e depois uma vez a cada retomada, e o programa salta diretamente para o ponto em que parou.
O programa [Async07.kt] demonstra tudo isso. Ele usa apenas a biblioteca padrão do Kotlin (não a kotlinx.coroutines), para que possamos ver os mecanismos básicos: ele escreve por conta própria o equivalente de [delay] e inicia uma corrotina por si mesmo.
Resultados:
Comentários:
- linha 15: um temporizador, isto é, um executor de thread única chamado [timer], capaz de executar uma ação após um atraso ([ScheduledExecutorService], Capítulo 8);
- linhas 17–21: a função de suspensão [pause], nosso próprio [delay]. Ela usa a função [suspendCoroutine] da biblioteca padrão (da qual [suspendCancellableCoroutine], encontrada em [Async02.kt], é a versão cancelável da kotlinx.coroutines): [suspendCoroutine] passa ao bloco a continuação da corrotina atual e depois a suspende. O bloco instrui o temporizador a retomar a continuação após o atraso especificado, com o valor [Unit];
- linhas 24–33: uma função de suspensão com dois pontos de suspensão (as duas chamadas a [pause]) e variáveis locais ([a], [b], [x], [y]) que precisam sobreviver às suspensões;
- linhas 39–46: uma corrotina é iniciada manualmente. A função [Continuation(context) { … }] cria uma continuação a partir de um bloco que recebe o resultado, do tipo [Result<Int>] (um resultado ou uma exceção; [getOrThrow()] retorna o primeiro ou lança a segunda): esta é a continuação final, que exibe o resultado e notifica a thread principal. O contexto vazio, [EmptyCoroutineContext], significa que nada específico é solicitado, em particular nenhum dispatcher. A função de extensão [startCoroutine] inicia uma lambda de suspensão ([suspend () -> Int]) como uma corrotina, com a continuação final;
- os resultados mostram a execução: [startCoroutine] executa a função [addUp] na thread [main] até o primeiro ponto de suspensão (linhas 3 e 4) e depois devolve o controle (linha 5): a função retornou [COROUTINE_SUSPENDED]. 300 ms depois, a thread [timer] retoma a execução: a função [addUp] continua logo após a primeira chamada a [pause], com o valor de [x] intacto (linha 6), em uma thread diferente daquela em que começou. Em seguida vêm a segunda pausa, o fim da função e a continuação final, que recebe o resultado 90 (linha 9). As corrotinas da kotlinx.coroutines não fazem nada além disso; os dispatchers apenas especificam qual thread executa cada continuação.
Vamos ver o que o compilador produziu. A ferramenta [javap] do JDK exibe os membros de uma classe compilada. O Gradle coloca as classes compiladas na pasta [build/classes/kotlin/main] do projeto:
- Linhas 6 e 7: as funções [pause] e [addUp] receberam um parâmetro final do tipo [Continuation], e seu tipo de retorno passou a ser [Object]. O parâmetro de continuação de [addUp] tem o mesmo tipo que seu resultado: [Continuation<? super Integer>]. Do ponto de vista do Java, [addUp] é um método comum que pode ser chamado passando-lhe uma continuação (é, aliás, assim que o código Java pode chamar uma função de suspensão, embora com alguma dificuldade);
- Linha 8: a função [main] sem parâmetros, ao lado do método [main(String[])] que o compilador adiciona para a JVM (linha 10), como vimos no Capítulo 3.
O compilador também gerou uma classe chamada [Async07Kt$addUp$1]: é o objeto de continuação da função [addUp]:
- linha 3: a classe deriva de [ContinuationImpl], uma classe interna da biblioteca padrão que implementa [Continuation];
- Linhas 4 a 7: quatro campos inteiros, [I$0] a [I$3], nos quais a função armazena suas variáveis locais [a], [b], [x], e [y] antes de cada suspensão;
- linha 8: [result] recebe o resultado (ou a exceção) com o qual a execução é retomada;
- linha 9: [label], o número do próximo ponto de retomada;
- linha 11: [invokeSuspend], o método chamado na retomada, que simplesmente chama a função [addUp], passando-lhe este objeto de continuação.
Por fim, a opção [-c] de [javap] exibe o bytecode dos métodos. Aqui estão dois trechos do bytecode de [addUp] (o comando [javap -c -p -cp build/classes/kotlin/main async07.Async07Kt] exibe o bytecode completo):
- No ponto de entrada da função (antes do trecho), o bytecode recupera o objeto de continuação da função, se for uma retomada, ou cria um, se for a primeira chamada;
- [getCOROUTINE_SUSPENDED] lê o valor especial [COROUTINE_SUSPENDED], armazenado em uma variável local;
- [tableswitch] é a instrução da JVM que corresponde a uma operação [when] sobre um inteiro: dependendo do valor do campo [label] (0, 1 ou 2), a execução salta para o início da função (endereço 92), logo após a primeira chamada a [pause] (endereço 153) ou logo após a segunda (endereço 242). Qualquer outro valor resulta em um erro (endereço 295).
- endereços 112 a 138: antes da primeira chamada a [pause], a função copia suas variáveis locais [a], [b] e [x] (variáveis 0, 1 e 3 da JVM) para os campos [I$0], [I$1] e [I$2] do objeto de continuação e define [label] como 1;
- endereço 141: a chamada a [pause(300)], com o objeto de continuação como último parâmetro;
- endereços 144 a 152: se [pause] retornou [COROUTINE_SUSPENDED], a função, por sua vez, retorna [COROUTINE_SUSPENDED] ao seu chamador ([areturn]): é assim que a suspensão “sobe” pela pilha de chamadas até [startCoroutine], que devolve o controle à thread [main]. Caso contrário, a execução continua diretamente no endereço 178;
- endereços 153 a 170: ponto de retomada nº 1. A função copia os campos do objeto de continuação para suas variáveis locais e então prossegue como se nada tivesse acontecido.
A pilha de chamadas da JVM nunca é, portanto, preservada: a cada suspensão, todas as funções atualmente suspensas retornam [COROUTINE_SUSPENDED], e seus quadros de pilha desaparecem; o que precisa sobreviver é armazenado nos objetos de continuação, que são encadeados entre si (cada um conhece a continuação de seu chamador). A cada retomada, a cadeia é percorrida em ordem inversa. É o mesmo conceito da “máquina de estados” que o compilador C# cria para um método [async].
Para compreender bem esse mecanismo, o programa [Async08.kt] escreve manualmente, em Kotlin, uma versão simplificada do que o compilador gerou para [pause] e [addUp]:
Resultados:
Comentários:
- Linhas 16–20: a função [pause] como o compilador a vê: uma função comum (sem [suspend]) que recebe a continuação a retomar, agenda sua retomada e retorna [COROUTINE_SUSPENDED], uma constante do pacote [kotlin.coroutines.intrinsics] da biblioteca padrão;
- linhas 23–29: o objeto de continuação de [addUp]. Ele conhece a continuação do chamador ([caller]), os parâmetros [a] e [b], o número do próximo ponto de retomada ([label]) e as variáveis locais [x] e [y]. O compilador, por sua vez, também armazena os parâmetros em campos e reutiliza campos genéricos ([I$0]…);
- linha 30: uma continuação deve fornecer o contexto de sua corrotina; usamos o do chamador;
- linhas 33–37: a retomada. O timer chama [resumeWith] no fim de uma pausa; o método chama [addUp] novamente com o objeto de continuação, que sabe onde retomar. Se a função é executada até o fim (ela não retorna [COROUTINE_SUSPENDED]), seu resultado é passado à continuação do chamador: é assim que o resultado “volta” de uma função de suspensão para aquela que a chamou;
- linhas 42–63: a máquina de estados. A chamada de [when] a [state.label] direciona a execução para a seção correta da função. Cada seção termina salvando o próximo ponto de retomada e chamando [pause]: se [pause] retorna [COROUTINE_SUSPENDED], a função também o retorna; caso contrário (uma função de suspensão pode ser executada até o fim sem suspender, por exemplo se o resultado já é conhecido), o laço [while (true)] passa diretamente para a próxima seção. As variáveis locais são lidas e gravadas no objeto de continuação ([state.x], [state.y]);
- linhas 76–77: a primeira chamada. Os resultados mostram que [addUp] retornou [COROUTINE_SUSPENDED] (linha 5 dos resultados); o restante do processo ocorre na thread [timer], exatamente como em [Async07.kt].
Este programa é incluído apenas para fins ilustrativos: você nunca escreveria esse código por conta própria. No entanto, há duas lições essenciais:
- uma corrotina suspensa custa apenas seus objetos de continuação — algumas dezenas de bytes por função ativa — em vez de uma pilha de um megabyte como a de uma thread de plataforma: foi isso que tornou possíveis as 100.000 corrotinas de [Async01.kt];
- a suspensão só é possível em chamadas a funções de suspensão. Uma função comum não pode ser suspensa: se ela bloqueia (como [Thread.sleep]), bloqueia a thread. Essa é a diferença fundamental em relação às threads virtuais, nas quais a JVM pode suspender qualquer código bloqueante escrito em Java. Em contrapartida, as corrotinas não dependem da JVM: o mesmo mecanismo funciona com Kotlin/JS em um navegador de thread única e com Kotlin/Native.
9.3.4. Dispatchers: qual thread executa o restante do código?
Uma corrotina não é uma thread: são necessárias threads para executá-la. O componente que decide qual thread executa uma corrotina — na inicialização e depois a cada retomada — é o seu dispatcher, um elemento do contexto da corrotina. O contexto de uma corrotina ([CoroutineContext]) é um pequeno conjunto de elementos indexados por seu tipo, que são combinados por meio do operador [+]: o dispatcher ([CoroutineDispatcher]), o [Job] da corrotina, seu nome ([CoroutineName]) e seu tratador de exceções ([CoroutineExceptionHandler], que veremos mais adiante)… Um contexto é passado como parâmetro para [launch], [async], [runBlocking], ou [withContext]; a nova corrotina herda os elementos do contexto de seu escopo, exceto aqueles que são substituídos.
O kotlinx.coroutines fornece quatro dispatchers, que são propriedades do objeto [Dispatchers]:
Dispatcher | Threads utilizadas |
[Dispatchers.Default] | Um pool de threads para cálculos, com tantas threads quantos forem os processadores (no mínimo duas). É o dispatcher usado quando nenhum é especificado e o escopo não possui um. |
[Dispatchers.IO] | Um pool de threads para operações bloqueantes (arquivos, JDBC, sockets bloqueantes), que pode conter até 64 threads (ou mais, se a máquina tiver mais de 64 processadores; a propriedade de sistema [kotlinx.coroutines.io.parallelism] altera esse limite). Ele compartilha suas threads com [Dispatchers.Default], o que evita uma troca de thread ao passar de um para o outro. |
[Dispatchers.Main] | a thread da interface gráfica. Ele só existe se o módulo correspondente for adicionado ao projeto: [kotlinx-coroutines-android], [kotlinx-coroutines-swing], [kotlinx-coroutines-javafx]. |
[Dispatchers.Unconfined] | Nenhuma thread específica: a corrotina começa na thread do chamador e, após uma suspensão, continua na thread que a retomou. É usado principalmente em testes e em casos muito específicos. |
Além desses dispatchers, há o de [runBlocking], que executa suas corrotinas na thread que o chamou, e aqueles criados a partir de um executor Java por meio da função de extensão [asCoroutineDispatcher()]. O programa [Async09.kt] exibe a thread que executa cada trecho de código:
Resultados:
Comentários:
- Linha 16: a propriedade de sistema [kotlinx.coroutines.debug] ativa o modo de depuração do kotlinx.coroutines (ela deve ser definida antes do primeiro uso da biblioteca; também pode ser passada à JVM: [-Dkotlinx.coroutines.debug]). Nesse modo, o nome da thread que executa uma corrotina é complementado, durante a execução, pelo nome da corrotina (fornecido por um elemento [CoroutineName] em seu contexto, ou [coroutine] por padrão) e por seu número: [main @main#1];
- linhas 18–22: a corrotina de [runBlocking], chamada [main], é executada pela thread [main], tanto antes quanto depois da espera: [runBlocking] transforma a thread que o chama em um laço de eventos que executa suas corrotinas (linhas 3 e 4 dos resultados);
- linhas 24–26: uma corrotina iniciada em [Dispatchers.Default], cujo contexto — formado com [+] — consiste em um dispatcher e um nome; ela é executada por uma thread chamada [DefaultDispatcher-worker-N] (linha 5);
- linhas 29–31: uma corrotina iniciada em [Dispatchers.IO]; ela é executada por uma thread com o mesmo nome (linha 6), já que os dois dispatchers compartilham suas threads;
- linhas 34–39: [withContext(context) { … }] é uma função de suspensão que executa um bloco em um contexto diferente — neste caso, outro dispatcher — dentro da mesma corrotina (o número permanece [#1]), depois volta ao dispatcher original e retorna o resultado do bloco (linhas 7 e 8). É o método padrão para executar um cálculo em [Dispatchers.Default] ou um código bloqueante em [Dispatchers.IO] sem alterar a forma do código: [val text = withContext(Dispatchers.IO) { file.readText() }];
- linhas 41–45: com [Dispatchers.Unconfined], a corrotina começa na thread [main] — a thread do chamador (linha 9) — e continua após [delay] na thread que a retomou: [kotlinx.coroutines.DefaultExecutor], a thread de timer do kotlinx.coroutines, que gerencia os timeouts (linha 10). Esse é o comportamento das continuações não assíncronas de [CompletableFuture] ([thenApply], [thenRun]), que são executadas pela thread que conclui a operação;
- Linhas 48–54: [Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher()] cria um dispatcher que atribui cada segmento de execução da corrotina a um executor Java — neste caso, um executor de threads virtuais. O dispatcher resultante deve ser fechado quando não for mais necessário, daí o uso de [use]. As linhas 11 e 12 mostram que o início e o restante da corrotina foram executados por duas threads virtuais diferentes (nºs 25 e 28): cada retomada é uma nova tarefa atribuída ao executor, que cria, portanto, uma nova thread virtual. Um dispatcher assim é útil para executar código bloqueante a partir de corrotinas sem ficar limitado pelo teto de 64 threads de [Dispatchers.IO]: as threads virtuais são liberadas pela JVM enquanto esperam;
- linhas 57–60: duas corrotinas que exibem uma mensagem e depois esperam, três vezes seguidas, em [Dispatchers.Default]. [joinAll] espera o término de várias corrotinas. As linhas 13 a 18 mostram que uma corrotina não permanece presa a uma única thread: a corrotina B começa em [worker-2] e continua em [worker-1]. Portanto, em uma corrotina, nunca se deve presumir que o código posterior a uma suspensão seja executado pela mesma thread que o código anterior. Uma consequência prática: uma variável [ThreadLocal] (Capítulo 8) não é confiável em uma corrotina; em vez disso, a informação é armazenada no contexto da corrotina, que a acompanha em toda parte;
- linhas 72–75: para uma thread virtual — cujo nome é vazio por padrão — exibimos sua descrição completa, que inclui seu número, seu nome (aqui, o da corrotina, adicionado pelo modo de depuração) e sua thread hospedeira.
A escolha do dispatcher é, portanto, importante:
- [Dispatchers.Default] para cálculos. Uma corrotina que realiza um cálculo demorado ocupa uma de suas threads, exatamente como faria uma tarefa em um pool de threads: as corrotinas não aceleram os cálculos; elas facilitam a concorrência de operações de espera (tratar muitas operações de espera simultaneamente), e não o paralelismo de cálculos (executar vários cálculos ao mesmo tempo em vários processadores, como visto no capítulo anterior);
- [Dispatchers.IO], ou um dispatcher de threads virtuais, para código bloqueante, junto com [withContext];
- [Dispatchers.Main] em uma aplicação gráfica: uma corrotina iniciada na thread da interface pode atualizar os componentes gráficos, esperar uma operação (executada em outro lugar com [withContext]) sem congelar a interface e depois atualizá-la com o resultado, sem exigir nenhum tratamento especial: ao final de [withContext], a corrotina volta automaticamente à thread da interface. É assim que funciona o C#, em que a continuação de um método [async] volta à thread da interface, e é algo que o Java não permite sem passar explicitamente um executor a cada continuação.
Por fim, é possível limitar o número de threads que um dispatcher aloca a um conjunto de corrotinas com [limitedParallelism(n)]: [val base = Dispatchers.IO.limitedParallelism(10)] retorna um dispatcher que nunca executa mais de 10 corrotinas ao mesmo tempo, usando as threads de [Dispatchers.IO]. Com [limitedParallelism(1)], obtemos um dispatcher que executa apenas uma corrotina por vez, o que permite manipular um estado compartilhado sem bloqueios. Esse recurso, estável desde a versão 1.9 do kotlinx.coroutines, será usado mais adiante neste capítulo, na seção sobre paralelismo limitado.
9.3.5. O programa principal
Um programa que usa corrotinas deve iniciar a primeira delas a partir do código comum da função [main] e esperar seu término: caso contrário, a função [main] terminaria imediatamente, e o programa junto com ela (as threads dos dispatchers são threads daemon, que não impedem a JVM de encerrar). Há duas maneiras de fazer isso:
- [fun main() = runBlocking { … }], que usamos desde o início do capítulo: [runBlocking] bloqueia a thread [main] até o fim da corrotina e de todas as corrotinas que ela iniciou. É o único lugar em que uma espera bloqueante é normal; nunca se deve chamar [runBlocking] a partir de uma corrotina ou de uma função de suspensão, pois isso bloqueia sua thread. Quando a última expressão do bloco não é do tipo [Unit], escrevemos [runBlocking<Unit> { … }]; caso contrário, a função [main] teria um tipo de retorno diferente, e a JVM deixaria de reconhecê-la como o programa principal;
- [suspend fun main()]: a função [main] pode ser, ela própria, uma função de suspensão; o compilador cuida de iniciá-la como corrotina. Isso equivale ao método [static async Task Main()] em C#.
O programa [Async10.kt] faz uma contagem regressiva usando uma função de suspensão [main]:
Resultados, primeiro com e depois sem argumento:
Comentários:
- linha 7: uma função de suspensão [main] , que recebe argumentos de linha de comando passados via Gradle por meio da opção [--args];
- Linha 9: [singleOrNull()] retorna o único argumento ou [null] se não houver exatamente um, e [toIntOrNull()] o converte em um inteiro ou retorna [null] se não for um inteiro;
- linhas 10–13: se o argumento estiver ausente ou incorreto, o programa termina com [exitProcess(1)] (uma função de [kotlin.system], que chama [System.exit]). O inteiro passado é o código de saída do programa (0 para sucesso, qualquer outro valor para um erro), que pode ser verificado por um script: [echo %ERRORLEVEL%] no Windows, [echo $?] no Linux. Quando iniciado pelo Gradle, um programa que termina com um código diferente de 0 faz a tarefa [run] falhar, e o Gradle então exibe suas próprias mensagens de erro após as do programa (elas não são reproduzidas aqui). O tipo de [exitProcess] é [Nothing] (Capítulo 3): o compilador sabe que essa função nunca retorna e, portanto, considera que, após o [if], [nbSeconds] não é [null]; ele pode ser usado como um [Int] (conversão inteligente de tipo);
- Linhas 20–24: a contagem regressiva. O programa Java devia implementá-la por meio de recursão, com cada etapa encadeando a seguinte com [thenCompose]; aqui, é um laço comum, com um [delay] em cada iteração;
- Os resultados revelam uma peculiaridade de [suspend fun main]: sua corrotina não tem dispatcher. Ela começa na thread [main] e, depois das esperas, continua na thread que a retomou — a thread de timer do kotlinx.coroutines ([kotlinx.coroutines.DefaultExecutor]) — exatamente como com [Dispatchers.Unconfined]. Isso não tem consequências aqui, mas é um motivo para preferir [fun main() = runBlocking { … }], cujo comportamento é mais bem definido, ou para especificar um dispatcher com [withContext] no corpo da função.
9.4. Concorrência estruturada
O curso de Java encerrou seu capítulo com uma visão geral da concorrência estruturada ([StructuredTaskScope], ainda em fase de preview no Java 25). Em Kotlin, ela não é apenas um complemento: é o princípio sobre o qual toda a biblioteca kotlinx.coroutines se baseia, e é preciso compreendê-la antes de prosseguir.
A ideia é simples: uma corrotina só pode ser iniciada dentro de um escopo ([CoroutineScope]), e o escopo só termina quando as corrotinas que ele iniciou terminam. As funções [launch] e [async] são funções de extensão de [CoroutineScope]: elas não podem ser chamadas em qualquer lugar, mas apenas dentro de um escopo, como o bloco de um [runBlocking], de um [launch] ou de um [async], cujo receptor ([this]) é um escopo. Cada escopo tem um [Job]; cada corrotina iniciada no escopo tem seu próprio [Job], que se torna filho do [Job] do escopo. As corrotinas de um programa formam, assim, uma árvore, cujas relações de parentesco têm três consequências:

- um pai espera seus filhos: um
*[Job]só termina quando seu próprio código e todos os seus filhos terminaram. É por isso que*[runBlocking]esperava as corrotinas iniciadas em seu bloco sem que fosse preciso escrever nenhum código para isso; - o cancelamento se propaga para baixo: cancelar um [Job] cancela todos os seus filhos e os filhos deles;
- a falha se propaga para cima: se um filho falha (seu código lança uma exceção), seu pai é cancelado, o que por sua vez cancela todos os seus outros filhos, e a exceção é repassada ao pai, depois ao pai deste, até a raiz ou até um trecho de código que a trate.
Como resultado, nenhuma corrotina pode ser “esquecida”: ela vive dentro de um escopo, que não pode terminar sem ela; se ela falha, alguém saberá; se a operação de que ela faz parte é abandonada, ela é encerrada. É a mesma disciplina dos blocos de código da programação estruturada (um bloco não termina antes das instruções que contém), aplicada à concorrência, daí o seu nome.
O programa [Async11.kt] ilustra essas três regras:
Resultados:
Comentários:
- linha 14: a última expressão do bloco é uma expressão [try] cujo tipo não é [Unit]; por isso, o tipo do resultado de [runBlocking] é especificado, como indicado no parágrafo anterior;
- Linhas 15–26: uma corrotina [parent] inicia dois filhos, que duram 300 e 600 ms, e depois exibe o número de seus filhos: dentro do bloco de um [launch], [coroutineContext] é o contexto da corrotina, [coroutineContext.job] é o seu [Job], e a propriedade [children] deste último é a sequência de seus filhos. O código do pai termina imediatamente (linha 2 dos resultados);
- linhas 28–30: 100 ms depois, o [Job] do pai ainda está ativo, assim como seus dois filhos (linha 3): um [Job] cujo código terminou está esperando seus filhos;
- linhas 31–32: [join()] só devolve o controle 600 ms depois, quando o segundo filho terminou (linhas 4–6);
- linhas 77–83: a função de suspensão [prepareBreakfast] trata três preparos simultaneamente. Para iniciar corrotinas, uma função de suspensão precisa de um escopo: [coroutineScope { … }] cria um novo escopo, cujo [Job] é filho da corrotina chamadora, executa o bloco, espera o término de todas as corrotinas iniciadas dentro do bloco e então retorna o valor do bloco. A função [prepareBreakfast] parece, portanto, vista de fora, uma função sequencial comum: quando ela devolve o controle, tudo o que ela iniciou está concluído, inclusive a corrotina da linha 82, que ninguém espera explicitamente terminar;
- linhas 34–37: a chamada da função; o café da manhã é servido após um segundo, a duração do preparo mais longo (linhas 7–13);
- linhas 39–54: um pai inicia dois filhos que esperam dez segundos. Após 200 ms, [cancelAndJoin()] aborta o pai e espera a conclusão do aborto: os dois filhos são abortados junto com ele (linhas 14–16). O bloco [finally] de cada filho é executado, exatamente como quando se sai de um bloco por meio de uma exceção: veremos na seção sobre cancelamento que é exatamente isso que acontece;
- linhas 56–73: dentro de um escopo criado por [coroutineScope], um filho espera dez segundos e seu irmão falha após 200 ms. A falha cancela o escopo, que por sua vez cancela o primeiro filho (linha 17), e [coroutineScope] lança a exceção do filho que falhou (linha 18), que é capturada por um [try / catch] comum que envolve a chamada.
Duas funções criam, portanto, um escopo, com dois usos diferentes:
- [runBlocking] cria o escopo raiz de um programa a partir de código comum, bloqueando a thread;
- [coroutineScope] cria um escopo dentro de uma função de suspensão, sem bloquear nenhuma thread. É a maneira padrão de escrever uma função de suspensão que realiza várias operações de forma concorrente: vista de fora, a concorrência não é visível.
Daí decorre uma regra de estilo: uma função de suspensão deve ter concluído todo o seu trabalho quando devolve o controle. Uma função que inicia corrotinas destinadas a sobreviver a ela não deve ser uma função de suspensão, e sim uma função de extensão de [CoroutineScope] (como o próprio [launch] ): [fun CoroutineScope.monitor(): Job]. Sua assinatura indica, assim, que ela inicia corrotinas no escopo do chamador. Mais adiante neste capítulo, veremos que a biblioteca também oferece escopos cujos filhos são independentes uns dos outros ([supervisorScope]) e como criar um escopo específico para um componente da aplicação. O final do capítulo comparará a concorrência estruturada do Kotlin com a do Java.
9.5. Execução sequencial e execução concorrente
9.5.1. async e awaitAll
Como mostrou o exemplo do café, uma chamada a uma função de suspensão é sequencial, e, para realizar várias operações simultaneamente, é preciso iniciá-las explicitamente em corrotinas. O momento em que uma operação é iniciada ([val d = async { operation() }]) e o momento em que ela é aguardada ([d.await()]) podem, assim, ser separados, permitindo que outras operações sejam iniciadas nesse intervalo. O programa [Async12.kt] compara as duas abordagens usando operações que levam um segundo:
Resultados:
Comentários:
- linhas 60–64: a operação simulada: uma espera de um segundo, seguida de uma “temperatura” derivada do comprimento do nome da cidade;
- Linhas 14–21: cada operação é chamada diretamente e, portanto, termina antes que a próxima comece: 3 segundos (linha 2 dos resultados). A função [measureTimedValue { … }] da biblioteca padrão ([kotlin.time]) executa o bloco e retorna um objeto [TimedValue], que contém o valor do bloco e a duração de sua execução; trata-se de uma data class, que é decomposta em duas variáveis ([val (sequence, duration1) = …], Capítulo 3). A duração é um [Duration], em que [inWholeMilliseconds] representa o número de milissegundos. Como o bloco é a [inline], funções de suspensão podem ser chamadas dentro dele;
- linhas 23–28: as três operações são iniciadas em três corrotinas com [async] e depois aguardadas. Elas são executadas simultaneamente: um segundo em vez de três (linha 3). A ordem das chamadas a [await] é irrelevante: a primeira espera a primeira operação terminar, enquanto as outras encontram as suas já concluídas ou quase;
- Linhas 32–35: o caso de uma lista de operações. [cities.map { city -> async { … } }] inicia uma corrotina por cidade e produz uma lista de [Deferred<Int>]; a função de extensão [awaitAll()] para uma coleção de [Deferred] espera por todos eles e retorna a lista de seus resultados, na ordem das operações (e não na ordem em que terminaram). As seis operações juntas levam um segundo (linha 4). Comparado à versão Java ([allOf] sobre um array de [CompletableFuture], seguido de uma continuação que coleta os resultados com [join]), o código é direto;
- linhas 39–43: o mesmo com uma função bloqueante ([readTemperatureBlocking], linhas 67–69), executada em [Dispatchers.IO]: cada operação bloqueia uma thread desse dispatcher; as seis juntas levam um segundo (linha 5);
- linhas 45–49: com 100 operações bloqueantes, o limite de 64 threads de [Dispatchers.IO] torna-se evidente: 64 operações, depois as 36 restantes, totalizando dois segundos (linha 6). É a mesma starvation de threads já encontrada com o pool de 10 threads de [Async01.kt], mas em escala maior;
- Linhas 51–56: as mesmas 100 operações bloqueantes em um dispatcher de threads virtuais: um segundo (linha 7), pois threads virtuais bloqueadas não retêm nenhuma thread do sistema. O parâmetro [virtuals] de [use] é o dispatcher, passado a [async] como contexto.
Essas duas últimas etapas demonstram como corrotinas e threads virtuais se complementam: corrotinas para o código escrito com funções de suspensão e threads virtuais — por meio de um dispatcher — para executar, a partir de corrotinas, uma grande quantidade de código bloqueante herdado do Java.
9.5.2. A primeira operação concluída: select
A função [select] (pacote [kotlinx.coroutines.selects]) suspende a corrotina até que ocorra um entre vários eventos e retorna o valor associado a esse evento. Cada evento possível é uma cláusula: [onAwait] para o término de um [Deferred] (a cláusula recebe seu resultado), [onJoin] para o término de um [Job], [onReceive] para a chegada de um valor em um canal… É o equivalente de [CompletableFuture.anyOf], com um resultado tipado. O programa [Async13.kt] o utiliza de três maneiras:
Resultados:
Comentários:
- Linhas 62–70: o servidor simulado responde após o tempo especificado. Se a corrotina que o consulta for cancelada durante a espera, [delay] lança uma [CancellationException]: nós a capturamos para sinalizar o problema e depois a relançamos (veremos na seção sobre cancelamento por que isso é essencial). [kotlinx.coroutines.CancellationException] é um alias da classe [java.util.concurrent.CancellationException] do JDK; a exceção efetivamente lançada é de uma classe interna da biblioteca derivada dela, [JobCancellationException];
- linhas 17–21: três servidores espelho são consultados; todos contêm as mesmas informações e respondem com velocidades variadas, cada um em uma corrotina;
- Linhas 23–26: o bloco [select] declara uma cláusula [onAwait] para cada consulta; a lambda de cada cláusula recebe o resultado da consulta e retorna o valor de [select]. As cláusulas podem ser declaradas dentro de um laço, como mostrado aqui. O primeiro [Deferred] a terminar prevalece: a primeira resposta chega após pouco mais de 300 ms (linha 2 dos resultados; o primeiro uso de [select] carrega mais algumas classes); seu tipo é [String], sem conversão de tipo, ao contrário de [anyOf], que retorna um [Object];
- linha 28: [select] não interrompeu as outras consultas, que continuam: [awaitAll()] espera que elas exibam todas as respostas (linha 3);
- Linhas 30–42: na maioria dos casos, as outras requisições tornaram-se desnecessárias. Ao contrário de um [CompletableFuture], uma corrotina pode ser realmente encerrada: [cancel()] cancela cada requisição (cancelar uma requisição que já foi concluída não tem efeito), e [joinAll()] espera o término das requisições canceladas. As linhas 4 e 5 dos resultados mostram que as duas requisições pendentes foram interrompidas durante a espera; elas não consomem mais nenhum recurso;
- linhas 44–59: um caso de uso clássico: uma corrida contra um limite de tempo. A cláusula [onJoin] do [Job] [timer], que espera 500 ms, retorna [null]; se ela vencer, a operação demorou demais e é cancelada (linhas 7–9). O tipo de [answer] é [String?]: [select] retorna a string da resposta ou [null]. O kotlinx.coroutines oferece uma maneira mais direta de tratar esse caso: a função [withTimeoutOrNull], descrita mais adiante.
9.5.3. Processando os resultados à medida que chegam
Muitas vezes queremos processar os resultados de várias operações à medida que elas terminam, sem esperar a mais lenta. O curso de Java fazia isso de duas maneiras: anexando uma continuação a cada [CompletableFuture] ou delegando as tarefas a um [ExecutorCompletionService], que entrega os [Future] na ordem em que as tarefas terminam. Com corrotinas, também há duas maneiras: usar o resultado dentro da própria corrotina que o produziu ou passar os resultados por um canal ([Channel]), uma fila entre corrotinas. O programa [Async14.kt] processa cinco “arquivos”, cada um dos quais leva entre 100 e 900 ms para ser processado, usando os dois métodos:
Resultados:
Comentários:
- linhas 36–39: o processamento simulado de um arquivo, que leva o tempo especificado;
- linhas 14–21: cada processamento é iniciado em sua própria corrotina, que exibe seu resultado assim que ele fica disponível: o arquivo 3 (100 ms) é exibido primeiro, o arquivo 0 (900 ms) por último (linhas 2–6 dos resultados). Isso equivale à continuação anexada a cada [CompletableFuture], mas o processamento e a exibição são escritos um após o outro: [display(process(...))]. O bloco [coroutineScope] espera o término das cinco corrotinas; ele substitui o [allOf] do programa Java. A função [forEachIndexed] percorre a lista [durations], devolvendo ao mesmo tempo o índice e o elemento;
- Linhas 23–33: as cinco corrotinas enviam seus resultados a um canal ([Channel<String>]) por meio da função de suspensão [send]; a corrotina principal os recebe um por um por meio da função de suspensão [receive()], que espera o próximo resultado disponível. Ela os recebe, portanto, na ordem em que os processamentos terminam (linhas 8–12): isso equivale ao [CompletionService] do Java, sem bloquear nenhuma thread. Um canal criado por [Channel<String>()] não tem buffer: cada [send] espera que uma corrotina receba o valor (é um “rendezvous”). Os canais serão discutidos em detalhes mais adiante neste capítulo;
- nos dois casos, o processo inteiro dura 900 ms — a duração da operação mais longa — e cada resultado é processado o mais cedo possível. A primeira abordagem é adequada quando cada resultado pode ser processado independentemente dos outros; a segunda é adequada quando um único trecho de código deve recebê-los todos, por exemplo, para agregá-los ou exibi-los em uma interface gráfica.
9.6. Exceções em corrotinas
9.6.1. try/catch e propagação na concorrência estruturada
Com [CompletableFuture], uma exceção não é lançada de volta ao código que iniciou a operação: ela é armazenada no [CompletableFuture], propaga-se ao longo da cadeia de continuações e é tratada por meio de métodos dedicados ([exceptionally], [handle], [whenComplete]). Com funções de suspensão, a questão é muito mais simples: uma função de suspensão lança exceções exatamente como uma função comum, e elas são capturadas com [try / catch], mesmo que a exceção tenha sido lançada em outra thread após uma suspensão. Há apenas uma coisa nova a aprender: o que acontece quando uma corrotina iniciada por [launch] ou [async] falha. O programa [Async15.kt] examina os diferentes casos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | |
Resultados:
Comentários:
- Linhas 86–91: a função testada. Ela primeiro verifica seu parâmetro com [require] (Capítulo 3), que lança uma [IllegalArgumentException] se a condição for falsa. Depois, espera 100 ms por caractere do texto e converte o texto inteiro, o que dispara uma [NumberFormatException] se ele não for um número;
- linhas 14–19: o caso normal. A exceção lançada por [toInt()] após a suspensão é capturada tal como está pelo [try / catch] do chamador: nem [CompletionException], nem [ExecutionException], nem o método [cause] é usado para chegar à exceção original (linha 2 dos resultados);
- linhas 22–28: [try] é uma expressão em Kotlin: seu valor é o do bloco [try] ou o do bloco [catch]. Isso equivale ao método [exceptionally] de [CompletableFuture] (linha 3). O parâmetro [_] indica que a exceção não é utilizada;
- linhas 30–39: [catch] converte uma falha em um resultado (o equivalente de [handle]), [finally] é executado em todos os casos (equivalente a [whenComplete]): linhas 4 a 7. As ferramentas usuais são utilizadas;
- linhas 42–46: em Java, um método que retorna um [CompletableFuture] podia falhar de duas maneiras — lançando uma exceção ao ser chamado (validação de parâmetros) ou retornando uma operação que falhou — e o chamador tinha de estar preparado para ambas. Uma função de suspensão tem apenas uma maneira de falhar: lançando uma exceção (linha 8);
- linhas 49–58: quatro leituras são iniciadas com
*[async]dentro de um escopo*[coroutineScope]*e são aguardadas com*[awaitAll()]*. A operação de leitura de ["two"] falha após 300 ms. De acordo com as regras da concorrência estruturada, a falha de um filho invalida seu pai, o escopo e, portanto, todos os seus outros filhos: a operação de leitura de ["four"], que deveria durar 400 ms, é invalidada. [coroutineScope] então lança a exceção do filho que falhou (linha 9). A linha 55 nunca é executada: [awaitAll()]* também lança a exceção; - linha 61: cada [Deferred] guardou seu resultado, que a função [outcome] (linhas 94–100) examina chamando [await()]: para uma operação concluída, [await()] retorna imediatamente seu resultado ou lança sua exceção e, para uma operação cancelada, lança uma [CancellationException]. As linhas 10 a 13 dos resultados mostram duas operações bem-sucedidas (["1"] e ["3"], que terminaram antes da falha), a falha e o cancelamento de ["four"]. Esse é o comportamento desejado na maioria dos casos: se qualquer uma das operações necessárias para um resultado falha, o resultado não pode ser produzido e não há por que continuar com as outras;
- Linhas 63–76: uma armadilha clássica. A exceção lançada por [await()] é capturada e substituída por um valor padrão, e o código continua (linhas 14 e 15); mas a falha do filho já foi propagada ao seu pai, que foi cancelado: ao final de seu bloco, [coroutineScope] lança a exceção de qualquer maneira (linha 16). Para impedir que uma falha afete o pai, é preciso ou capturá-la na própria corrotina que falha ([async { try { readValue("six") } catch (e: NumberFormatException) { -1 } }]) ou usar um escopo de supervisão;
- linhas 79–82: [supervisorScope { … }] cria um escopo de supervisão: como [coroutineScope], ele espera todos os seus filhos e os aborta se for abortado, mas a falha de um filho afeta somente ele mesmo: não aborta nem o escopo nem os outros filhos. Cada operação de leitura é executada até o fim, e o chamador examina o resultado de cada uma (linhas 17–20): desta vez, a operação de leitura de ["four"] falhou em vez de ser cancelada. É isso que se precisa quando as operações são independentes: exibir as temperaturas de seis cidades mesmo que uma delas não responda, por exemplo.
O curso de Java concluiu que as exceções em threads virtuais são tratadas como as do código comum, exceto na fronteira entre duas threads; isso também vale para as corrotinas, e a concorrência estruturada resolve o problema da fronteira: a falha de uma corrotina filha é automaticamente propagada de volta à corrotina pai.
9.6.2. As corrotinas esquecidas, CoroutineExceptionHandler, SupervisorJob e GlobalScope
O curso de Java mostrou que a exceção de uma operação que ninguém esperava era perdida, sem nenhuma mensagem. Na concorrência estruturada, uma corrotina não pode realmente ser esquecida: seu escopo a aguarda e, em um escopo comum, sua falha é propagada ao pai. Mas um escopo de supervisão não cancela o pai, e há maneiras de iniciar uma corrotina fora de qualquer estrutura: o que acontece com as exceções nesse caso? O programa [Async16.kt] demonstra isso:
Resultados:
Comentários:
- linhas 91–94: a operação usada por todos os casos, que falha após 200 ms;
- linhas 26–27: como no programa Java, configuramos o tratador chamado quando uma exceção não é capturada por nenhum código em uma thread. Sem ele, a JVM imprime o stack trace da exceção na saída de erro;
- linhas 18–20: um
*[CoroutineExceptionHandler]é um elemento de contexto que recebe as exceções que nenhuma corrotina tratou; ele é criado com uma lambda que recebe o contexto da corrotina que falhou e a exceção. [context[CoroutineName]] retorna o elemento [CoroutineName] do contexto, ou [null]* se não houver nenhum: o contexto é usado como um array associativo indexado pelo tipo dos elementos; - Todas as corrotinas dos casos 1 a 5 são iniciadas em um
*[supervisorScope]*: a falha de uma delas não se propaga ao pai; portanto, outra parte deve tratá-la; - linhas 31–36: a operação é aguardada com [await()]; sua exceção é capturada normalmente (linha 2 dos resultados);
- linhas 39–41: uma corrotina iniciada por [async], para a qual ninguém chama [await()]. Sua exceção é armazenada no [Deferred], que é ignorado: ela se perde, exatamente como a de um [CompletableFuture] esquecido, e nada a exibe. Uma corrotina iniciada por [async] foi concebida para ser aguardada; se seu resultado não for necessário, use [launch];
- linhas 43–45: uma corrotina iniciada por [launch] não tem um resultado no qual armazenar sua exceção. Se seu pai não a trata (como ocorre dentro de um escopo de supervisão), a exceção é passada ao [CoroutineExceptionHandler] do contexto e, na falta dele, ao tratador de exceções não capturadas da thread que executava a corrotina, neste caso [main] (linha 7). No entanto, a thread não é interrompida: ela continua a executar as outras corrotinas;
- linhas 47–49: a mesma corrotina, com um [CoroutineExceptionHandler] em seu contexto: é ele que recebe a exceção (linha 8);
- linhas 51–56: a melhor maneira de iniciar uma operação sem esperar seu resultado: a corrotina trata sua própria falha, com um [try / catch] (linha 9);
- linhas 60–65: o programa continua seu trabalho; ao final do bloco, [supervisorScope] espera todos os seus filhos, inclusive aqueles que pensávamos ter “esquecido”;
- Linhas 67–78: um componente da aplicação (uma tela, um serviço, uma conexão) que inicia corrotinas destinadas a durar tanto quanto o próprio componente — e não apenas durante uma chamada de função — precisa de seu próprio escopo. Ele é criado com a função [CoroutineScope(context)], geralmente junto com um [SupervisorJob()], um
*[Job]*em que a falha de um filho não encerra os outros (o equivalente de*[supervisorScope]para um escopo criado dessa maneira), um dispatcher e um tratador de exceções. As corrotinas iniciadas por [scope.launch { … }] são filhas do [SupervisorJob]: a falha de [saver-f], repassada ao tratador (linha 13), não impede que [counter] continue seu trabalho (linhas 12–15). Quando o componente desaparece, [scope.cancel()] cancela tudo o que o escopo iniciou: nenhuma corrotina sobrevive ao seu componente. É isso que fazem os escopos dos frameworks, como [viewModelScope] e [lifecycleScope]* no Android; - linhas 80–86: [GlobalScope] é um escopo global, sem [Job], que existe durante toda a vida do programa. Uma corrotina iniciada por [GlobalScope.launch] não tem pai: ninguém a espera, ninguém a cancela, e sua exceção é passada ao tratador da thread que a executava (neste caso, uma thread de [Dispatchers.Default], o dispatcher padrão de [GlobalScope]: linha 16). A segunda corrotina, que deveria exibir uma mensagem após um segundo, é simplesmente abandonada: [runBlocking] não a espera, e o programa termina sem ela (linha 17);
- linha 23: [GlobalScope] é anotado com [@DelicateCoroutinesApi]: usá-lo provoca um aviso do compilador, que é um erro com a opção [allWarningsAsErrors] em nosso projeto:
- A anotação [@OptIn(DelicateCoroutinesApi::class)] colocada na função informa ao compilador que sabemos o que estamos fazendo e faz o aviso desaparecer. Esse mecanismo de “opt-in” é usado pelas bibliotecas Kotlin para sinalizar APIs delicadas ou ainda experimentais.
A regra é a mesma do Java, mas a concorrência estruturada a torna quase automática: toda corrotina deve pertencer a um escopo que a espera, e sua falha deve ser tratada — seja pela própria corrotina, por seu pai ou por um [CoroutineExceptionHandler]. Evitamos [GlobalScope], exceto para raras corrotinas que realmente precisam viver tanto quanto o programa; em vez disso, criamos um escopo por componente, que destruímos ao fim de sua vida útil.
9.7. Cancelamento e timeouts
9.7.1. Cancelamento cooperativo
Uma operação demorada deve poder ser cancelada: o usuário clicou em [Cancel], um cliente de servidor se desconectou, uma janela da aplicação foi fechada ou um timeout foi excedido. O Java usa para isso a interrupção de threads: [interrupt()] define um flag; as esperas bloqueantes são interrompidas lançando [InterruptedException]; e um cálculo deve verificar o flag por conta própria. O curso de Java também apontou uma armadilha: o método [cancel] de um [CompletableFuture] não interrompe nada, pois um [CompletableFuture] não sabe qual thread trabalha para ele.
As corrotinas têm seu próprio mecanismo, que também é cooperativo, mas integrado à biblioteca:
- o método [cancel()] de um [Job] (ou de um [Deferred]) o coloca no estado “cancelando”; ele não encerra a corrotina à força, nem faz o chamador esperar. [join()] espera então o término da corrotina; [cancelAndJoin()] faz as duas coisas;
- se a corrotina está suspensa em uma das funções de suspensão do kotlinx.coroutines ([delay], [await], [join], [receive], [withContext]…), essa função retoma imediatamente a corrotina fazendo-a lançar uma [CancellationException]. O mesmo vale se a corrotina chamar uma dessas funções quando já estiver cancelada. Todas essas funções são ditas canceláveis;
- A exceção sobe pela pilha de chamadas como uma exceção comum, executando no caminho os blocos [finally] e as funções [use], o que libera os recursos de forma limpa. Ao chegar ao topo da corrotina, ela a encerra no estado “cancelada”; isso não é uma falha: uma [CancellationException] nunca é passada ao pai nem aos tratadores de exceções;
- uma corrotina que realiza cálculos sem nunca chamar uma função de suspensão não é afetada: ela deve verificar por conta própria seu estado com [isActive] (verdadeiro enquanto não for cancelada), [ensureActive()] (que lança uma [CancellationException] se ela foi cancelada) ou [yield()] (que cede a thread a outras corrotinas e verifica o cancelamento no processo);
- cancelar um [Job] cancela seus filhos, como vimos na concorrência estruturada.
O programa [Async17.kt] cancela um download simulado e um cálculo simulado de várias maneiras:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | |
Resultados:
Comentários:
- Linhas 84–95: o download simulado recebe um bloco a cada 300 ms. Ele não requer nenhuma medida especial para ser cancelável: [delay] é cancelável. Capturamos [CancellationException] para sinalizar o cancelamento e depois a relançamos: uma [CancellationException] capturada deve sempre ser relançada; caso contrário, a corrotina continuaria como se nada tivesse acontecido, mesmo estando cancelada (e qualquer função cancelável que ela chamasse em seguida lançaria imediatamente uma nova exceção). Pelo mesmo motivo, desconfie de um
***[catch (e: Exception)]**, que também captura*[CancellationException]*, ou da função da biblioteca padrão[runCatching]*, que captura tudo; - linhas 19–26: após um segundo, o programa cancela o download com
*[cancel()]e depois espera seu término com*[join()]. O download para imediatamente, no meio da espera pelo quarto bloco (linhas 2–5 dos resultados); uma corrotina cancelada e terminada tem [isCancelled=true] e [isCompleted=true] (linha 6). Ao contrário de [cancel] em um [CompletableFuture], a própria operação é interrompida, e não apenas a espera por seu resultado; - linhas 99–109: um bilhão de iterações de um cálculo arbitrário. Se solicitado, o cálculo verifica a cada dez milhões de iterações se sua corrotina ainda está ativa: [currentCoroutineContext()] retorna o contexto da corrotina atual, e sua propriedade de extensão [isActive] indica se o [Job] associado a esse contexto está ativo. Poderíamos ter escrito [currentCoroutineContext().ensureActive()] no lugar, o que lança uma [CancellationException] se a corrotina foi cancelada;
- linhas 28–34: o cálculo é iniciado em [Dispatchers.Default] sem verificação. O pedido de cancelamento aos 300 ms (linha 7) não tem efeito sobre ele: ele é executado até o fim (linha 8), e [cancelAndJoin()] espera essa conclusão. [Job] está, no entanto, no estado cancelado (linha 9);
- linhas 36–42: o mesmo cálculo, com a verificação: ele para alguns milissegundos após o pedido de cancelamento (linhas 10–12);
- linhas 44–57: um cálculo infinito é iniciado, desta vez na thread de [runBlocking], que ele compartilha com a corrotina principal. Sem [yield()], ele ficaria com a thread só para si: a corrotina principal nunca conseguiria ser retomada após seu [delay(300)], nem, portanto, cancelar o cálculo, e o programa nunca terminaria. [yield()] suspende a corrotina e a recoloca na fila de seu dispatcher, o que deixa a thread disponível para outras corrotinas; se a corrotina tiver sido cancelada nesse meio-tempo, [yield()] lança uma [CancellationException], que interrompe o laço (linhas 13 e 14);
- Linhas 59–81: limpeza de uma corrotina cancelada em um bloco [finally]. Fechar uma conexão pode exigir a chamada de uma função de suspensão; porém, uma corrotina cancelada não pode mais se suspender: qualquer função cancelável lança imediatamente uma [CancellationException], como mostra o [delay(100)] no bloco [finally] (linha 18). Para executar mesmo assim um código que suspende, ele é executado com [withContext(NonCancellable) { … }]: [NonCancellable] é um [Job] que nunca é cancelado, e o bloco é executado normalmente até terminar (linhas 19 e 20). O bloco deve ser curto: ele atrasa a conclusão do cancelamento, que [cancelAndJoin()] está esperando (linha 21).
Observe que o cancelamento não é uma interrupção abrupta: é uma exceção, lançada nos pontos de suspensão, que percorre o código de volta executando os blocos [finally]. Qualquer código escrito com funções de suspensão canceláveis pode ser cancelado sem esforço; um cálculo longo deve verificar regularmente [isActive] ou chamar [ensureActive()] ou [yield()].
9.7.2. Vários processos, vários resultados
O programa [Async18.kt] retoma o programa Java que iniciava cinco processos com duração de 1 a 5 segundos, dos quais o processo nº 3 lança uma exceção e o processo nº 4 é cancelado. Ele trata cada processo assim que termina, independentemente de como terminou, e sempre sabe de qual processo se trata:
Resultados:
Comentários:
- Linhas 53–60: o processamento. O processo nº 3 falha imediatamente: a função [check] (Capítulo 3) lança uma [IllegalStateException] se sua condição for falsa. Os outros “dormem” por [duration] segundos, em incrementos de um segundo, com [delay] (que pode ser cancelado), e retornam um resultado — uma data class ([ProcessingResult], linha 13) — que contém a duração prevista e a duração real;
- linha 20: os processos são independentes: dentro de um escopo de supervisão, a falha do processo nº 3 não cancela os outros;
- linha 21: os cinco processos são iniciados com [async]; a lista dos cinco [Deferred<ProcessingResult>] é construída por [List(5) { number -> … }];
- linhas 22–25: uma corrotina cancelará o processo nº 4 após 2,5 segundos, mesmo que ainda lhe restem 2,5 segundos de sono. O programa Java precisava de um
*[ScheduledExecutorService]*para isso; aqui, basta uma corrotina que começa com um*[delay]* ; - linha 30: [withIndex()] associa cada tarefa ao seu número, na forma de objetos [IndexedValue] (uma data class com duas propriedades, [index] e [value]), armazenados em uma lista mutável de processos em andamento;
- linhas 33–36: enquanto houver processos em andamento, [select] espera o primeiro terminar, independentemente de como ele termine: a cláusula [onJoin] de um [Job] é selecionada assim que ele é concluído — com sucesso, sem sucesso ou cancelado. A cláusula retorna o [IndexedValue] do processo, que é então removido da lista;
- linha 37: a atribuição por desestruturação separa o número do processo;
- linhas 39–46: o resultado do processamento é examinado com [await()], que não bloqueia mais a execução: ele retorna o resultado, lança a exceção do processamento ou lança uma [CancellationException] se ele foi cancelado. A ordem dos [catch] é importante: [CancellationException] deriva de [IllegalStateException] (é uma subclasse do JDK), portanto deve ser capturada primeiro. Capturar uma
*[CancellationException]*sem relançá-la é válido aqui porque ela vem de outro*[Job]*— o processo cancelado — e não da corrotina que a captura; - os resultados mostram que o nº 3 falha imediatamente, que os nºs 0, 1 e 2 terminam após 1, 2 e 3 segundos, respectivamente, e que o nº 4 é cancelado aos 2,5 segundos. O programa Java verificava o estado do [Future] usando [switch] para examinar as constantes de [Future.State]; com corrotinas, o resultado de um processo é lido naturalmente com [try / catch].
9.7.3. Limitando a duração de uma espera: withTimeout e withTimeoutOrNull
O kotlinx.coroutines fornece duas funções de suspensão que limitam a duração de um bloco de código:
- [withTimeout(timeout) { … }] executa o bloco e retorna seu valor; se o bloco não for concluído dentro do limite de tempo, ele é cancelado, e [withTimeout] lança uma [TimeoutCancellationException] (uma classe derivada de [CancellationException]);
- [withTimeoutOrNull(timeout) { … }] faz o mesmo, mas retorna [null] em vez de lançar uma exceção.
O timeout é expresso em milissegundos ou como uma duração ([withTimeout(2.seconds)]). O programa [Async19.kt] demonstra essas duas funções, seus limites (o código bloqueante) e como combinar duas condições de término:
Resultados:
Comentários:
- linhas 78–85: o servidor simulado, que sinaliza seu cancelamento;
- linhas 19–24: não esperamos uma resposta por mais de um segundo. Após um segundo, o bloco é cancelado: a operação realmente para (linha 2 dos resultados) e então [withTimeout] lança uma [TimeoutCancellationException], com uma mensagem que faz referência ao timeout (linha 3). Essa é uma diferença significativa em relação ao método [orTimeout] de [CompletableFuture], que abandonava a espera, mas deixava a operação continuar inutilmente;
- linhas 27–30: [withTimeoutOrNull] retorna [null] se o timeout for excedido; o operador Elvis [?:] então substitui [null] por uma resposta padrão (linhas 4 e 5). É o equivalente de [completeOnTimeout], porém mais curto e, novamente, a operação é realmente encerrada;
- linhas 32–39: o limite do cancelamento cooperativo. O bloco, limitado a um segundo, executa uma função bloqueante ([queryBlocking], linhas 89–97) em [Dispatchers.IO], que dorme por três segundos com [Thread.sleep]. Após um segundo, a corrotina de fato é cancelada, mas nada pode interromper [Thread.sleep]: a função é executada até o fim (linha 6), e só no retorno de [withContext], três segundos depois, é que [TimeoutCancellationException] é lançada (linha 7). A espera não serviu para nada;
- linhas 42–49: para garantir que cancelar uma corrotina interrompa o código bloqueante, ele é executado com [runInterruptible(dispatcher) { … }]: a função executa o bloco no dispatcher especificado e, se a corrotina for cancelada, interrompe a thread que o executa por meio do método [interrupt()] do Java. [Thread.sleep] então lança [InterruptedException] (linha 8), que [runInterruptible] converte em [CancellationException]. Isso cria uma ponte entre o cancelamento de corrotinas e a interrupção de threads: a operação para após um segundo (linha 9). Isso funciona apenas para código bloqueante interrompível ([Thread.sleep], as esperas em [java.util.concurrent], os canais em [java.nio]…);
- linhas 65–75: um processo que pode ser interrompido por duas razões — seu próprio timeout ou um pedido geral de parada do chamador. Ambas ocorrem na forma de uma exceção: uma [TimeoutCancellationException] disparada por [withTimeout] para o timeout e uma [CancellationException] para o cancelamento da corrotina pelo chamador. O timeout é um resultado normal do processamento, convertido em uma mensagem; já o cancelamento é sinalizado e depois relançado. As duas [catch] mensagens devem estar nessa ordem, já que [TimeoutCancellationException] deriva de [CancellationException];
- Linhas 52–62: três processos, filhos da mesma corrotina [all]. Para o término geral, o programa Java devia criar um [CompletableFuture] adicional e anexar a ele uma continuação que cancelava cada espera; aqui, o término geral é simplesmente o cancelamento do pai, que por sua vez cancela seus filhos. O processo [fast] termina normalmente (linha 10), o processo [slow] excede seu timeout de um segundo (linhas 11 e 12), e o processo [medium], ao qual foram concedidos 2 segundos, é encerrado pelo desligamento geral aos 1.200 ms (linhas 13–15).
9.8. Relatando o progresso
Uma operação demorada muitas vezes precisa relatar seu progresso (uma barra de progresso, uma porcentagem). A abordagem mais simples é passar-lhe uma função de callback que receba as atualizações de progresso. Em Java, era um [Consumer<T>]; em Kotlin, é simplesmente um parâmetro funcional (Capítulo 7), [(Progress) -> Unit]. A operação chama essa função a cada etapa; ela não sabe nada sobre como os relatórios de progresso serão exibidos.
Em uma aplicação gráfica, surge a questão das threads: os componentes gráficos só podem ser atualizados pela thread da interface. Com corrotinas, a resposta é simples: se a corrotina que executa a operação foi iniciada em *[Dispatchers.Main], os relatórios são emitidos na thread da interface, e a função de callback pode atualizar os componentes diretamente; se a operação realiza parte de seu trabalho em outro lugar (com [withContext(Dispatchers.IO)]), ela relata seus resultados fora desse bloco, ou a função de callback volta à thread da interface com [withContext(Dispatchers.Main)] (ela é então, ela própria, uma função de suspensão, do tipo [suspend (Progress) -> Unit]). Em um programa de console, ela pode exibir a saída diretamente. O programa [Async20.kt] simula uma cópia de arquivos que o usuário pode cancelar digitando [Enter]*:
Resultados sem cancelamento (a entrada padrão está fechada: [readlnOrNull()] retorna imediatamente [null]):
Resultados quando o usuário digita [Enter] durante a operação de cópia, após cerca de um segundo e meio (a linha vazia digitada não aparece: a entrada foi fornecida ao programa por redirecionamento de sua entrada padrão):
Comentários:
- linha 11: um relatório de progresso, uma data class contendo a porcentagem e o nome do arquivo;
- linhas 31–39: a operação, uma função de suspensão. Seu parâmetro [progress] é do tipo [((Progress) -> Unit)?]: uma função que aceita um [Progress] e não retorna nada, ou [null] se o chamador não quiser relatórios, que é o valor padrão. Após cada arquivo, ela relata seu progresso por meio de [progress?.invoke(...)]: a chamada com [?.] não faz nada se [progress] for [null] (não é possível chamar [progress?(...)]: é preciso usar o método [invoke] do tipo funcional). A espera de 300 ms, com [delay], torna a operação cancelável;
- linhas 42–46: exibição de um relatório: uma barra de 20 caracteres construída com [repeat]. A referência de função [::display] (linha 16) é a função de callback passada à operação;
- linha 16: a cópia é realizada por uma corrotina na thread de [runBlocking];
- linhas 17–21: uma thread espera o usuário digitar [Enter] e então cancela a cópia. [readlnOrNull()] é uma leitura bloqueante da entrada padrão, que não pode ser cancelada. Portanto, ela não pode ser executada em uma corrotina no escopo de [runBlocking]: a concorrência estruturada forçaria [runBlocking] a esperar o término dessa corrotina — isto é, que o usuário digite algo — mesmo depois de a cópia ter terminado. Ela é executada em uma thread criada pela função [thread] com [isDaemon = true]: uma thread daemon, que o programa descarta ao terminar. Este é um caso em que é preciso sair deliberadamente da concorrência estruturada; isso é feito com uma ferramenta explícita (uma thread daemon), e não com [GlobalScope]. O método [cancel()] de um [Job] pode ser chamado a partir de qualquer thread;
- Linhas 24–27: o programa espera o término da cópia. O cancelamento resulta em uma [CancellationException] lançada por [await()]. Como em [Async18.kt], ela pode ser interceptada sem reiniciá-la, pois resulta do cancelamento de outra corrotina — a operação de cópia; uma falha da operação de cópia, por outro lado, se propagaria para [runBlocking] e encerraria o programa.
Uma função de callback é adequada para relatórios simples. O restante deste capítulo apresentará uma ferramenta mais geral para produzir uma sequência de valores de forma assíncrona: o fluxo ([Flow]): uma operação que retorna um [Flow<Progress>] informa seus resultados à medida que ficam disponíveis, e o chamador os coleta com [collect], no dispatcher de sua escolha.
9.9. Entrada/saída assíncrona
9.9.1. Arquivos
A E/S é a própria razão de ser da assincronia. Para arquivos, o JDK oferece duas famílias de classes, que o Kotlin usa diretamente:
- as classes “clássicas” e bloqueantes: [Files], [BufferedReader], [BufferedWriter] e as funções de extensão que o Kotlin acrescenta a elas (Capítulo 5): [readLines], [readText], [useLines], [bufferedWriter], [writeText], [appendText]… Em um programa com corrotinas, elas são executadas no dispatcher [Dispatchers.IO], destinado a operações bloqueantes, junto com [withContext(Dispatchers.IO) { … }]: a corrotina chamadora é suspensa — sem bloquear sua thread — enquanto uma thread do dispatcher [IO] executa a operação;
- a classe [AsynchronousFileChannel] (Java 7), cujas operações retornam um [Future] ou chamam um [CompletionHandler]. Ela raramente é usada: no Linux, na verdade realiza leituras bloqueantes em um pool de threads interno da JVM, e sua interface é desajeitada. Ela é adaptada para corrotinas com [suspendCancellableCoroutine], como o cliente TCP do programa [Async02.kt].
O programa [Async21.kt] exibe as duas famílias lendo, a partir da thread principal, o arquivo das faixas do imposto, [TaxData.txt], localizado na raiz do projeto:
Cada linha contém o limite da faixa, o coeficiente [coeffR] e o coeficiente [coeffN], separados pelo caractere [:] e escritos com ponto decimal (a tabela do imposto é a de 2004 para a renda de 2003, mantida como está para este exercício fiscal). O programa é executado na pasta [09-async] (que é a pasta atual para [gradlew run]) e procura seus arquivos na pasta atual. O arquivo [taxpayers.txt], que será usado no exercício ao final do capítulo, fica no mesmo local.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | |
Resultados:
Comentários:
- Linhas 47–57: leitura com um [AsynchronousFileChannel], apresentada como uma função de suspensão que retorna o conteúdo do arquivo. O canal é um [Closeable]: a função [use] (Capítulo 3) o fecha ao final do bloco, qualquer que seja o resultado, inclusive se a corrotina for cancelada. É a mesma técnica usada no programa [Async02.kt]: [suspendCancellableCoroutine] suspende a corrotina e devolve o controle ao bloco; a operação de leitura é iniciada com um objeto de callback que retoma a corrotina com o número de bytes lidos ([resume]) ou com a exceção ([resumeWithException]). O programa Java precisava construir e concluir por conta própria um [CompletableFuture] e depois fechá-lo em uma continuação [whenComplete]; aqui, o código é lido de cima para baixo. Uma única leitura basta para um arquivo pequeno; um arquivo grande exigiria leituras sucessivas, que seriam simplesmente escritas dentro de um laço na corrotina;
- Linha 33: a função Kotlin [lines()] divide uma string em linhas; se a string termina com uma quebra de linha, a lista termina com uma string vazia (ao contrário do método Java [lines()]). [trimEnd()] remove essa última quebra de linha;
- linha 61: as outras operações são operações comuns de E/S bloqueante, agrupadas na função de suspensão [processFiles], cujo corpo inteiro é executado por [withContext(Dispatchers.IO)]. O nome da thread exibido na linha 3 dos resultados ([DefaultDispatcher-worker-…]) mostra que já não é a thread principal que está executando. O programa Java delegava essas operações a uma thread virtual e precisava interceptar a [IOException] dentro da lambda de um [Runnable]; em Kotlin, não existem exceções verificadas, e uma [IOException] lançada dentro do bloco de [withContext] seria relançada na corrotina chamadora;
- linha 63: [readLines()], uma função de extensão de [Path] (pacote [kotlin.io.path]), lê o arquivo inteiro e retorna uma lista de suas linhas (em UTF-8 por padrão);
- linha 67: [useLines] abre o arquivo, passa ao bloco uma sequência ([Sequence<String>]) de suas linhas — lidas sob demanda — e fecha o arquivo ao final do bloco: isso equivale ao laço com [readLine()] do programa Java, sem tratar [null] nem usar [try] com recurso. Cada linha é convertida em [TaxBracket] pela função [parse] do objeto companion da data class (linhas 102–106). Ela divide a linha com [split], converte os três campos em [BigDecimal] usando a referência de construtor [::BigDecimal] e os recupera por meio de uma atribuição com desestruturação. O construtor de [BigDecimal] espera um ponto decimal, independentemente do idioma da máquina. A representação produzida pelo método [toString] da data class aparece na linha 4 dos resultados;
- linha 71: a sequência de linhas não carrega o arquivo inteiro na memória; essa é a abordagem preferível para arquivos grandes. Ela só pode ser usada dentro do bloco [useLines], já que o arquivo é fechado ao sair dele;
- Linhas 73–82: escrita com um [BufferedWriter], obtido pela função de extensão [bufferedWriter()] e fechado (e, portanto, descarregado em disco) por [use]. O formato [%,d] insere o separador de milhares específico do idioma da máquina (uma vírgula em inglês, um espaço fino não separável em francês); o produto [bracket.coeffR * BigDecimal(100)] usa o operador [*] definido pela biblioteca padrão do Kotlin para [BigDecimal] (função de extensão [times], Capítulo 4);
- linhas 86–92: [readText()] relê o arquivo escrito, [appendText] acrescenta uma linha a ele, [last()] retorna o último elemento da lista, e depois [deleteExisting()] exclui o arquivo;
- linhas 38–43: vários arquivos são lidos em paralelo. Cada operação de leitura é tratada por uma corrotina ([async]), e [awaitAll()] espera os três resultados. A função [readSlowly] (linhas 96–98) simula uma leitura bloqueante de 500 ms em um disco lento; como ela é executada no dispatcher [IO], as três leituras ocupam três threads diferentes e juntas levam 500 ms, e não 1,5 s (linha 16 dos resultados). Observe que as corrotinas são lançadas por [async] sem um dispatcher: é a função chamada que escolhe, por meio de [withContext], o dispatcher adequado à sua tarefa. Esta é a regra a seguir: uma função de suspensão bloqueante deve ela mesma passar pelo dispatcher IO, para que o chamador possa invocá-la a partir de qualquer thread sem tomar nenhuma precaução especial.
O dispatcher [IO] limita por padrão a 64 o número de threads ativas ao mesmo tempo (programa [Async12.kt]). Para ler milhares de arquivos simultaneamente, é possível criar um dispatcher baseado em threads virtuais (programa [Async09.kt]); lembre-se da limitação mencionada no curso de Java: as leituras e escritas de arquivos fixam a thread virtual à sua thread hospedeira durante a operação. Para arquivos locais, isso raramente é um problema; para operações de rede, as threads virtuais e as corrotinas de fato liberam sua thread durante as esperas.
9.9.2. Rede: HttpClient
O cliente HTTP do JDK, [java.net.http.HttpClient] (Java 11), oferece duas abordagens: [send], que é bloqueante e retorna a resposta, e [sendAsync], que retorna imediatamente um [CompletableFuture] contendo a resposta. Em uma corrotina, esperamos esse [CompletableFuture] com a função de suspensão [await()] do pacote [kotlinx.coroutines.future], que já encontramos no programa [Async04.kt]: a corrotina fica suspensa até a resposta chegar, sem bloquear nenhuma thread. O Capítulo 12 examinará esse cliente em detalhes; o programa [Async22.kt] apenas compara os dois métodos consultando um pequeno servidor HTTP local, que leva um segundo para retornar a “temperatura” de uma cidade:
Resultados:
Comentários:
- Linhas 26–38: o servidor. A JVM contém um pequeno servidor HTTP, que é a classe [HttpServer] do módulo [jdk.httpserver] (pacote [com.sun.net.httpserver]). Ele é criado no endereço local ([getLoopbackAddress()]) e na porta 27510; [createContext] associa um handler — uma lambda que recebe a troca HTTP — ao caminho [/temperature] (a interface Java [HttpHandler] tem apenas um método: a lambda Kotlin é convertida nela; trata-se de uma conversão SAM, Capítulo 7). O handler decodifica o parâmetro [city] a partir do endereço solicitado ([removePrefix] remove a parte inicial [city=]), espera um segundo e então envia a resposta; [toByteArray()] codifica a string em UTF-8. A linha 37 faz com que cada requisição seja processada por uma thread virtual: um servidor configurado dessa forma pode atender milhares de clientes em espera. Observe a notação [server.executor = …]: o Kotlin apresenta o par de métodos Java [getExecutor] / [setExecutor] como uma propriedade, assim como [getRequestURI()] se torna [requestURI] e [getResponseBody()] se torna [responseBody];
- Linha 41: o cliente é criado por um construtor ([newBuilder]), que aqui define a versão do protocolo. A partir do Java 21, ele implementa [AutoCloseable]: a função [use] o fecha ao final do bloco. Uma requisição inicial serve para “aquecer” a JVM: o primeiro uso de um cliente carrega numerosas classes, o que distorceria a medição seguinte em algumas centenas de milissegundos;
- linhas 64–67: a função de suspensão [readTemperature]. [sendAsync(request, handler)] envia a requisição e retorna imediatamente um [CompletableFuture<HttpResponse<String>>]; o handler de corpo [BodyHandlers.ofString()] especifica que o corpo da resposta deve ser lido como uma string. [await()] suspende a corrotina até a resposta chegar, e o corpo é armazenado ([body()]). Onde o programa Java encadeava uma continuação ([thenApply(HttpResponse::body)]), simplesmente escrevemos as chamadas uma após a outra;
- linhas 45–48: seis corrotinas, uma por cidade, enviam suas requisições ao mesmo tempo; as respostas chegam juntas após um segundo (linha 2 dos resultados). Durante a espera, nenhuma thread aguarda a resposta: o cliente monitora suas conexões por meio de uma thread “seletora”, que conclui o [CompletableFuture]; a retomada das corrotinas fica então a cargo do dispatcher de [runBlocking], isto é, da thread principal. O programa Java precisava combinar os [CompletableFuture] com [allOf] e depois ler seus resultados com [resultNow]; [awaitAll()] faz as duas coisas;
- Linhas 50–57: [send] é bloqueante; ele é chamado a partir de seis corrotinas executadas no dispatcher [IO], cada uma das quais ocupa uma thread durante a espera. O resultado é o mesmo: um segundo para as seis requisições (linha 3). Essa abordagem funciona para algumas requisições; para milhares delas, [sendAsync] e [await()] não ocupam nenhuma thread durante a espera;
- linhas 59–60: o servidor é encerrado ao final do programa, qualquer que seja o resultado; o parâmetro de [stop] é o número de segundos concedidos para que as trocas em andamento terminem;
- linhas 70–72: a requisição GET. [URLEncoder.encode] codifica os caracteres que não podem aparecer como estão em um endereço (o [É] de Évry), e o servidor os decodifica com [URLDecoder.decode];
- a variável [start] (linha 23) é uma variável de alto nível modificável ([var]), reinicializada com a hora atual antes de cada medição; a função [display] exibe o tempo decorrido desde [start], como nos programas anteriores.
Guarde a seguinte regra: diante de uma API Java que retorna um CompletableFuture, uma corrotina espera por ele com await()**; diante de uma API bloqueante, ela a chama no dispatcher [IO]. Nos dois casos, o código da corrotina permanece sequencial.
9.10. Fluxos assíncronos de valores
Uma operação assíncrona retorna um resultado após certo tempo. Uma sequência ([Sequence], Capítulo 5) ou um iterador retorna uma sequência de valores, produzidos sob demanda. Às vezes é preciso combinar as duas coisas: uma sequência de valores em que cada um exige uma espera antes de ser produzido. É o caso das linhas de um arquivo grande, das linhas do resultado de uma consulta SQL, das mensagens que chegam por uma conexão de rede, das leituras de sensores e assim por diante. O curso de Java apresentou dois modelos: o modelo “pull”, em que o consumidor solicita o próximo valor e espera que ele chegue (um [Stream] em que cada valor bloqueia, lido por uma thread virtual), e o modelo “push”, em que o produtor envia valores a seus assinantes, que controlam a vazão (as interfaces [java.util.concurrent.Flow] do Java 9 e a classe [SubmissionPublisher]).
O Kotlinx.coroutines oferece duas ferramentas que cobrem esses dois modelos:
- o fluxo ([Flow<T>], pacote [kotlinx.coroutines.flow]): uma sequência de valores produzida por uma função de suspensão, a pedido do consumidor. É o equivalente assíncrono de uma sequência, com operadores ([map], [filter], [take]…) que são, eles próprios, funções de suspensão. Um fluxo é passivo: nada é produzido até que alguém o colete, e cada coleta reinicia a produção;
- o canal ([Channel<T>]), já encontrado no programa [Async14.kt]: uma fila entre corrotinas, em que o produtor envia ([send]) e o consumidor recebe ([receive]), cada um sendo suspenso se o outro não acompanhar o ritmo. Um canal é “quente”: o produtor opera independentemente do consumidor. Os fluxos compartilhados ([SharedFlow], [StateFlow]) também são quentes.
O C# oferece os fluxos assíncronos [IAsyncEnumerable<T>] para o mesmo fim, produzidos por [yield return] e consumidos por [await foreach]: o [Flow] do Kotlin é o equivalente.
9.10.1. Fluxos
Um fluxo é criado pela função [flow { … }], cujo bloco é uma função de suspensão que emite seus valores com [emit(value)]; ele é consumido pela função de suspensão [collect { value -> … }], que executa seu bloco para cada valor emitido. O programa [Async23.kt] incorpora o programa Java que gerava medições — uma a cada 200 ms — na forma de um [Stream<Measurement>]:
Resultados:
Comentários:
- Linhas 57–67: o produtor. A função [readMeasurements] não é uma função bloqueante: ela retorna imediatamente um [Flow<Measurement>] sem produzir nada. O bloco de [flow] só será executado quando um consumidor coletar o fluxo. Ele espera 200 ms com [delay] e depois envia uma medição com [emit]; [emit] é uma função de suspensão que chama o bloco [collect] do consumidor e só devolve o controle depois que o valor foi processado: cada medição é processada antes que a seguinte seja produzida. O bloco [finally] é o “[finally] do produtor”: ele substitui a ação [onClose] do bloco Java de [Stream] e é executado independentemente de como a coleta termine;
- Linha 24: cada medição é processada assim que é produzida: uma a cada 200 ms (linhas 2–5 dos resultados; a primeira chega um pouco depois, enquanto a JVM carrega as classes do fluxo), e então o produtor termina (linha 6). Não há fluxos a fechar: o fim da coleta de dados marca o fim da produção;
- linhas 26–31: o operador [onEach] executa uma ação para cada valor que passa, e a função de suspensão [first { condition }] coleta o fluxo até o primeiro valor que satisfaz a condição, retorna esse valor e interrompe a coleta. O produtor não produz as 96 medições restantes: seu [emit] lançou uma exceção interna de cancelamento, que o interrompeu e executou seu [finally] (linha 11 dos resultados). Para obter o mesmo resultado, o programa Java precisava percorrer o stream por meio de seu iterador e sair com [break];
- linhas 33–44: o cancelamento. O fluxo é coletado por outra corrotina, que a corrotina principal cancela após 700 ms com [cancelAndJoin()]. O [delay] da quarta medição é cancelado: ele dispara uma [CancellationException] que atravessa o produtor (seu [finally] é executado, linha 16 dos resultados), depois [collect], e então chega ao [catch] do leitor (linha 17), que a relança, como esperado. Nenhuma interrupção de thread é necessária: trata-se do cancelamento cooperativo das corrotinas;
- linhas 46–53: os operadores [filter], [map] e [take] transformam o fluxo e retornam um novo fluxo; eles têm o nome das funções para coleções e sequências (Capítulo 5). A função de suspensão [toList()] coleta o fluxo em uma lista. [take(4)] interrompe a coleta após quatro valores: o produtor, configurado para 100 medições, para na sexta (o resultado fica disponível após aproximadamente 6 × 200 ms). O programa Java coletava seis medições e as filtrava; aqui, o fluxo poderia ser infinito;
- linhas 72–77: o método [toString] da data class [Measurement] é redefinido para uma exibição mais compacta; [NumberFormat.getInstance()] formata o número real de acordo com o idioma da máquina, sem casas decimais desnecessárias ([21], [21.75]).
É importante distinguir os dois tipos de funções da API de fluxos:
- operadores intermediários ([map], [filter], [take], [onEach], [flowOn], [buffer], [catch]…) não são funções de suspensão: eles retornam imediatamente um novo fluxo, que descreve um processo, sem executar nada;
- operadores terminais ([collect], [toList], [first], [single], [reduce], [fold], [count]…) são funções de suspensão: eles disparam a produção e esperam que ela termine.
Esse é o modelo usado nas sequências do Kotlin (e no [Stream] do Java), mas agora cada etapa pode esperar sem bloquear uma thread. O programa [Async20.kt] informava o progresso de uma operação por meio de uma função de callback; uma operação também pode retornar um [Flow<Progress>] e informar seu progresso em tempo real, com o chamador coletando esses relatórios com [collect].
9.10.2. Fluxos frios, flowOn, buffer e catch
O programa [Async24.kt] demonstra quatro propriedades dos fluxos: eles são frios, seu produtor pode trocar de dispatcher, um buffer pode desacoplar o produtor do consumidor, e as exceções ocorridas a montante podem ser interceptadas:
Resultados:
Comentários:
- linhas 57–61: o fluxo de teste: um inteiro a cada 200 ms. O parâmetro [trace] (valor padrão [true]) exibe o início da produção e a thread que a executa;
- Linhas 20–25: criar o fluxo não produz nada (linha 2 dos resultados: nenhum rastro do produtor). Cada coleta ([toList()]) reexecuta o bloco de [flow] desde o início (linhas 3 e 5): um fluxo é uma receita de produção, e não uma fonte de valores já em trânsito. Essa é a diferença em relação a um canal, que será discutido adiante;
- linhas 27–32: por padrão, o produtor é executado na corrotina do coletor, em seu dispatcher: a linha 3 dos resultados mostra que o produtor da Parte 1 era executado na thread [main]. O operador [flowOn(dispatcher)] faz tudo o que o precede (o produtor e [map]) ser executado em outro dispatcher, neste caso [Dispatchers.Default], enquanto a coleta permanece na thread [main] (linhas 7–9). Essa é a ferramenta para aplicações gráficas: a produção (leitura de um banco de dados ou da rede) ocorre em [Dispatchers.IO] ou [Default], enquanto a coleta dos dados (a exibição) ocorre na thread da interface. Nunca se deve trocar o dispatcher dentro do bloco de [flow] com [withContext] em torno de um [emit]: a biblioteca detecta isso e lança uma [IllegalStateException]; [flowOn] é a única forma correta;
- linhas 34–43: sem buffer, [emit] espera o coletor processar o valor: a produção (200 ms) e o processamento (300 ms) ocorrem em sequência, e os cinco valores levam 5 × 500 = 2.500 ms (linha 10 dos resultados). O operador [buffer()] coloca um canal entre o produtor e o coletor, que passam então a ser executados em duas corrotinas diferentes: o produtor prepara o valor seguinte enquanto o coletor processa o anterior, e o processo inteiro leva 200 + 5 × 300 = 1.700 ms (linha 11). A função [measureTime] da biblioteca padrão mede a duração de um bloco. O buffer tem uma capacidade (64 valores por padrão; use [buffer(10)] para outro valor): quando ele está cheio, o produtor fica suspenso até que uma vaga seja liberada. Esse é o backpressure dos fluxos reativos, obtido sem nenhum protocolo de requisição: um produtor suspenso deixa de produzir;
- linhas 66–69: um fluxo que falha após dois valores;
- Linhas 45–53: o operador [catch] captura as exceções lançadas a montante (pelo produtor e pelos operadores anteriores, neste caso [onEach]). Seu bloco recebe a exceção e pode exibi-la, retornar valores de substituição (aqui, [-1], linha 17 dos resultados) ou lançar outra exceção. Ele não intercepta as exceções a jusante (as do bloco [collect]): para essas, a coleta é envolvida por um [try / catch] padrão, que também intercepta as exceções a montante. Diferentemente de um [catch (e: Exception)], o operador [catch] deixa passar a exceção de término da corrotina que coleta o fluxo: ele não impede o término.
Outros operadores costumam ser úteis: [transform] (emite zero, um ou mais valores para cada valor recebido), [onCompletion] (uma ação ao final do fluxo, com sua causa, se houver), [retry] (retoma a produção após um erro), [distinctUntilChanged] (ignora um valor igual ao anterior), [conflate] (um coletor lento recebe apenas o valor mais recente), [scan] (resultados sucessivos de uma acumulação), [combine] e [zip] (combinam dois fluxos).
9.10.3. Canais: um produtor, um consumidor
Um fluxo é “frio”: sua produção é responsabilidade do consumidor. Quando a fonte produz em seu próprio ritmo, seja ou não lida (um sensor, mensagens recebidas, eventos), é necessário um fluxo “quente”. O mais simples é o canal ([Channel<T>], pacote [kotlinx.coroutines.channels]), uma fila para corrotinas: ele é o equivalente de uma [BlockingQueue] (Capítulo 8), em que as operações que bloqueavam a thread ([put], [take]) se tornam funções de suspensão ([send], [receive]). Sua capacidade é definida na criação:
- [Channel<T>()] ([Channel.RENDEZVOUS]): sem buffer; cada [send] espera um [receive] (programa [Async14.kt]);
- [Channel<T>(n)]: um buffer contendo [n] valores; [send] só espera quando o buffer está cheio;
- [Channel<T>(Channel.UNLIMITED)]: um buffer ilimitado; [send] nunca espera (com o risco de encher a memória);
- [Channel<T>(Channel.CONFLATED)]: uma única vaga; um novo valor substitui aquele que não foi lido.
O programa [Async25.kt] faz um consumidor lento ler as medições de um produtor que começa a trabalhar sem esperá-lo:
Resultados:
Comentários:
- Linhas 37–54: o produtor. A função [produceMeasurements] é uma extensão de [CoroutineScope]: ela lança uma corrotina dentro do escopo do chamador ([launch] se aplica ao receptor implícito [this], o escopo) e retorna imediatamente o canal para o qual essa corrotina enviará suas medições. Essa é a convenção do kotlinx.coroutines: uma função que lança corrotinas e retorna sem esperar por elas é uma extensão de CoroutineScope; uma função que espera o término de seu trabalho é uma função de suspensão. O tipo retornado, [ReceiveChannel<Measurement>], é a parte “receber” do canal: o chamador só pode receber;
- linha 39: um canal com capacidade de 2;
- linha 45: [send] coloca a medição no buffer, ou suspende o produtor se ele estiver cheio;
- linhas 49–50: ao final da produção — normal ou não — o produtor fecha o canal. Fechar o canal não apaga os valores do buffer: o consumidor ainda os receberá e só depois saberá que o canal está fechado;
- Linhas 17–19: o produtor começa imediatamente, enquanto o consumidor só lerá o canal 700 ms depois. Nesse intervalo, as medições nº 1 e nº 2 enchem o buffer (linhas 2–3 dos resultados); a medição nº 3, pronta por volta de 600 ms, não pode ser entregue: [send] suspende o produtor. Assim que o consumidor recebe a medição nº 1, uma vaga é liberada e a medição nº 3 é entregue (linhas 5–6). Em seguida, o produtor passa a acompanhar o ritmo do consumidor, enviando uma medição a cada 500 ms: esse é o backpressure, obtido simplesmente pela suspensão de [send];
- linhas 21–26: um canal é processado com um laço [for], que recebe os valores um a um e termina quando o canal está fechado e vazio. O produtor terminou em 1.743 ms (linha 11 dos resultados); o consumidor ainda lê as duas medições do buffer (linhas 12–13) antes de sair do laço (linha 14);
- linhas 28–33: [receive()] recebe um valor por vez; após duas medições, o consumidor para de ler com [cancel()], que fecha o canal e apaga seu buffer. O próximo [send] do produtor então dispara uma [CancellationException], que encerra sua corrotina após executar [finally] (última linha dos resultados). Sem esse [cancel()], o produtor — bloqueado por um buffer cheio — nunca terminaria, e [runBlocking], que espera seus filhos, tampouco. Também é possível percorrer um canal com [channel.consumeEach { … }], que cancela o canal ao sair do bloco, qualquer que seja o motivo.
O Kotlinx.coroutines oferece uma função, [produce], que faz o que [produceMeasurements] faz (lança uma corrotina que escreve em um canal e retorna o canal), mas ela ainda está marcada como experimental: usá-la dispara esse aviso, de modo que ocorre um erro com a opção [allWarningsAsErrors] em nosso projeto:
Neste curso, não usamos a API experimental (seria preciso aceitá-la explicitamente com a anotação [@OptIn(ExperimentalCoroutinesApi::class)], e ela poderia mudar em uma versão futura): o canal e o [launch] escrito à mão fazem a mesma coisa em poucas linhas.
Um canal entrega cada valor a um único consumidor: se várias corrotinas leem o mesmo canal, elas dividem os valores entre si. É isso que se precisa para distribuir trabalho entre workers (veremos isso na seção sobre paralelismo limitado), mas não para transmitir valores a vários assinantes.
9.10.4. Fluxos compartilhados: vários assinantes
Para transmitir cada valor a todos os assinantes, o kotlinx.coroutines oferece o fluxo compartilhado: [MutableSharedFlow<T>], no qual o publicador transmite com [emit], é visto pelos assinantes como um [SharedFlow<T>], que eles coletam como qualquer outro fluxo. Ele é o equivalente do [SubmissionPublisher] do curso de Java, e o programa [Async26.kt] usa o mesmo exemplo: seis medições publicadas para dois assinantes, um display rápido que cancela a assinatura quando a temperatura ultrapassa 22 °C e um arquivo lento:
Resultados:
Comentários:
- Linha 19: o publicador, um fluxo compartilhado de medições. O parâmetro [extraBufferCapacity = 2] dota-o de um buffer de 2 valores: o publicador pode estar até 2 valores à frente do assinante mais lento. O tipo do valor é [Measurement?]: o valor [null] servirá para sinalizar o fim da publicação;
- linhas 21–27: a tela é uma corrotina que coleta o fluxo de dados até a primeira leitura de pelo menos 22 °C, com [first] (programa [Async23.kt]): a assinatura começa com a coleta de dados e termina com ela. Não há [onSubscribe], nem [request(1)], nem [cancel()]: todo o protocolo de fluxo de dados reativo consiste em coletar os dados e depois parar;
- linhas 29–35: o arquivo processa cada medição em 500 ms. Durante esse processamento, a coleta de dados não avança: é isso que regula a vazão, como o [request(1)] do assinante Java;
- Linha 51: um fluxo compartilhado nunca termina: um assinante que o coleta espera indefinidamente pelos próximos valores até que sua corrotina seja cancelada. Não há equivalente ao método [close()] do publicador Java. Para sinalizar o fim, emite-se um valor predefinido — neste caso, [null]. A função de extensão [untilTheEnd] interrompe a coleta nesse valor ([takeWhile]) e retorna um [Flow<Measurement>] ([filterNotNull] muda o tipo dos valores, de [Measurement?] para [Measurement]);
- Linha 39: um fluxo compartilhado não retém nada para assinantes ausentes: um valor publicado quando ninguém está inscrito é perdido (a menos que o fluxo seja instruído a reenviar alguns deles aos novos assinantes, com o parâmetro [replay]). A propriedade [subscriptionCount] é um fluxo do número de assinantes: esperamos até que ele chegue a 2 antes de publicar. Sem essa precaução, os dois assinantes, lançados por [launch], ainda não teriam começado a coletar dados no momento da primeira transmissão;
- Linhas 40–47: o publicador publica uma medição a cada 200 ms. [emit] é uma função de suspensão: quando o buffer do assinante mais lento está cheio, ela espera que uma vaga seja liberada. A medição nº 5, pronta por volta de 1.300 ms, só é publicada em 1.507 ms (linha 14 dos resultados), quando o arquivo já pegou a medição nº 3. Esse é o backpressure: o publicador é desacelerado ao ritmo do assinante mais lento;
- os resultados são os do programa Java: a tela processa cada medição assim que é publicada e cancela a assinatura na medição nº 4 (linhas 11–12), enquanto o arquivo, que leva 500 ms por medição, fica para trás e recebe as seis medições, seguidas do fim do fluxo (linha 20). O programa termina quando os dois assinantes terminam: eles são filhos de [runBlocking], que os espera.
Um tipo específico de fluxo compartilhado é amplamente usado: o fluxo de estado ([MutableStateFlow<T>] / [StateFlow<T>]). Ele sempre tem um valor — o valor atual — que pode ser lido e modificado por meio de sua propriedade [value] ([state.value = "connected"]); seus assinantes recebem o valor atual assim que se inscrevem e, depois, cada novo valor (um valor igual ao anterior não é emitido, e um assinante lento recebe apenas o mais recente). Essa é a ferramenta usada pelas aplicações gráficas e Android para representar o estado de uma tela: a lógica de negócio modifica o estado, a interface do usuário o coleta, e a tela é redesenhada a cada mudança. É o equivalente assíncrono das propriedades observáveis tratadas no Capítulo 7.
Pontos principais:
Ferramenta | Uso |
[Flow] (frio) | uma sequência de valores gerados sob demanda para um consumidor: linhas de um arquivo, resultados de uma consulta, páginas de uma API |
[Channel] (quente) | uma fila entre corrotinas: cada valor é recebido por um único consumidor (produtor/consumidores, balanceamento de carga) |
[SharedFlow] (quente) | uma transmissão: cada valor é recebido por todos os assinantes presentes (eventos, mensagens) |
[StateFlow] (quente) | Um estado observável: um valor atual e suas mudanças |
9.11. Cache, retorno à thread correta e conclusão manual da operação
9.11.1. Um cache para operações assíncronas
Um [Deferred], como um [CompletableFuture], é um objeto: cada chamada a uma função que retorna um deles aloca pelo menos um objeto no heap, que o coletor de lixo precisará recuperar. Isso é desprezível para uma E/S que dura milissegundos. As funções de suspensão, de fato, têm uma vantagem sobre os objetos [CompletableFuture]: uma função de suspensão que já tem seu resultado o devolve diretamente, sem suspender a corrotina, sem trocar de thread e sem criar um objeto [Deferred]; da mesma forma, [await()] em um [Deferred] que já foi concluído retorna seu valor sem suspender. É o que outras linguagens obtêm com um tipo “leve” (a estrutura [ValueTask] do C#, por exemplo).
Quando se quer que várias requisições concorrentes pelo mesmo valor compartilhem a mesma operação em andamento, a melhor prática continua sendo armazenar em cache os próprios objetos [Deferred] em si: um valor já conhecido é retornado por um [Deferred] concluído, e um valor que está sendo calculado é retornado pelo [Deferred] desse cálculo. O programa [Async27.kt] aplica isso ao serviço de taxas de câmbio do programa Java:
Resultados:
Comentários:
- Linha 44: o serviço lança corrotinas (as leituras) que devem poder sobreviver à corrotina que as solicitou: uma leitura solicitada por um chamador é compartilhada com os chamadores seguintes. Portanto, elas não podem pertencer ao escopo de um chamador; pertencem a um escopo próprio do serviço — um escopo de componente (programa [Async16.kt]). Seu [SupervisorJob] garante que a falha de uma leitura não cancele as outras; seu dispatcher é [Dispatchers.Default];
- linha 83: o serviço implementa [AutoCloseable]; seu fechamento cancela o escopo e, portanto, todas as leituras em andamento. O programa principal usa o serviço dentro de um bloco [use] (linha 20): nenhuma corrotina sobrevive a ele;
- linha 47: o cache associa cada código de moeda ao [Deferred] de sua taxa de câmbio, concluído ou ainda em andamento. Trata-se de um [ConcurrentHashMap] (Capítulo 8), pois ele pode ser usado por várias threads ao mesmo tempo (a thread principal, as threads do dispatcher [Default] que executam as leituras);
- linhas 50–51: os contadores são objetos [AtomicInteger] privados, expostos externamente por duas propriedades somente leitura cujo acessor [get()] lê o valor atual (Capítulo 4);
- linhas 53–56: [computeIfAbsent(key, function)] retorna o valor associado à chave, se existir; caso contrário, chama a função (aqui, a referência [::readServerRate]), armazena seu resultado no dicionário e o retorna. Em um [ConcurrentHashMap], essa operação é atômica: duas corrotinas que solicitam ao mesmo tempo uma moeda ausente disparam um único acesso ao servidor. [readRate] não é uma função de suspensão: ela retorna um [Deferred], que o chamador espera com [await()] quando quiser;
- linhas 60–61: a operação de leitura é iniciada por [async] com a opção [start = CoroutineStart.LAZY]: a corrotina é criada, mas não começa; ela começará na primeira chamada a [start()] ou [await()]. [readRate] a inicia por meio de [.also { it.start() }], depois que [computeIfAbsent] a armazenou no cache ([start()] não tem efeito sobre uma corrotina que já começou ou terminou). Essa precaução garante que a operação de leitura não possa terminar — nem tentar remover a si mesma do cache — antes de ter sido armazenada nele; ela também impede que qualquer coisa seja executada dentro da função [computeIfAbsent], que deve ser curta porque é executada enquanto o dicionário está bloqueado para aquela chave;
- linhas 64–71: a consulta simulada ao servidor (300 ms). A expressão [when] aplicada a uma string retorna a taxa de câmbio ou lança uma exceção para uma moeda desconhecida;
- linhas 73–76: em caso de falha, a operação é removida do cache para que uma solicitação posterior da mesma moeda consulte o servidor novamente, em vez de retornar indefinidamente a mesma falha. A remoção é feita na corrotina antes de ela terminar: o chamador que recebe a exceção por meio de [await()] encontra um cache já atualizado (o programa Java obtinha a mesma garantia com [whenComplete]). A exceção é relançada; se for uma [CancellationException] (encerramento do serviço), ela também é relançada, e uma leitura cancelada tampouco permanece no cache;
- linhas 21–26: para o chamador, uma leitura é uma operação assíncrona como qualquer outra: ele a espera com [await()]. A função [measureTimedValue] retorna ao mesmo tempo o resultado do bloco e sua duração, recuperados por meio de uma atribuição com desestruturação. Os resultados mostram os 3 acessos ao servidor (300 ms cada; um pouco mais no primeiro, durante o qual a JVM carrega as classes necessárias) e as 4 respostas imediatas do cache;
- linhas 28–31: três solicitações simultâneas da taxa de câmbio do franco suíço obtêm o mesmo objeto (o operador [===] compara as referências) e resultam em um único acesso ao servidor (linha 10 dos resultados);
- linhas 33–37: [await()] relança a exceção da leitura, que é capturada por um [catch] padrão (o programa Java recebia uma [CompletionException] que envolvia a exceção original); a moeda desconhecida já não está no cache (linha 11). A função [currenciesInCache] retorna as chaves do dicionário ordenadas ([sorted()]).
O cache de [Deferred] é adequado quando cada valor é calculado independentemente dos outros. Em contrapartida, quando apenas uma corrotina por vez pode executar uma seção de código com suspensão, usa-se um lock de corrotinas — especificamente, a classe [Mutex] do pacote [kotlinx.coroutines.sync]: [mutex.withLock { … }] executa o bloco de forma mutuamente exclusiva, e uma corrotina que encontra o lock ocupado fica suspensa sem bloquear sua thread. Um cache simples seria implementado com [suspend fun readRate(code: String) = mutex.withLock { cache.getOrPut(code) { readServerRate(code) } }], junto com um [MutableMap] padrão, que o lock protege. É mais simples que o cache de [Deferred], mas faz todas as leituras — mesmo as de outra moeda — esperarem durante cada acesso ao servidor. Não se devem usar os locks do Capítulo 8 ([synchronized], [ReentrantLock]) em torno de uma chamada de suspensão: eles pertencem a uma thread, ao passo que uma corrotina pode ser retomada em uma thread diferente daquela em que adquiriu o lock ([synchronized] em torno de uma chamada de suspensão é, de fato, rejeitado pelo compilador).
9.11.2. Voltando à thread da interface gráfica
O programa [Async09.kt] demonstrou que é o dispatcher que decide qual thread executa uma corrotina — e, portanto, qual thread executa o restante do código após uma suspensão. Em uma aplicação gráfica, isso importa: um componente gráfico só pode ser manipulado pela thread da interface. Enquanto o Java exige que o programa retome a execução nessa thread por conta própria ([SwingUtilities.invokeLater] com Swing, [Platform.runLater] com JavaFX), o kotlinx.coroutines oferece um dispatcher dedicado, [Dispatchers.Main], cujas corrotinas são executadas na thread da interface:
- ele é fornecido por um módulo complementar específico da biblioteca gráfica: [kotlinx-coroutines-android] (Android), [kotlinx-coroutines-javafx] (JavaFX), [kotlinx-coroutines-swing] (Swing); sem esse módulo, usá-lo lançará uma exceção:
- O código da interface é executado em corrotinas lançadas em [Dispatchers.Main] e passa para outro dispatcher durante uma tarefa demorada: [val page = withContext(Dispatchers.IO) { download(address) }], depois [textArea.text = page]. Após [withContext], a corrotina voltou automaticamente à thread da interface: não há nada a solicitar. É o que o [await] do C# faz em uma aplicação gráfica, retomando o método na thread da interface;
- No Android, os componentes fornecem seu próprio escopo, vinculado ao seu ciclo de vida ([lifecycleScope] para uma activity, [viewModelScope] para um view model), cujo dispatcher é [Dispatchers.Main]: quando a tela é destruída, o escopo é cancelado e, com ele, todas as corrotinas que ele havia lançado. Essa é a concorrência estruturada aplicada às interfaces;
- o coletor de um fluxo é executado no dispatcher da corrotina que coleta (a thread da interface), enquanto [flowOn] faz os valores serem gerados em outro lugar (programa [Async24.kt]). Um [StateFlow] coletado em [Dispatchers.Main] é a forma padrão de exibir um estado que muda.
A regra continua a mesma do curso de Java: a thread da interface nunca deve bloquear ([runBlocking], [Thread.sleep], [join()] de um [CompletableFuture], E/S bloqueante), sob pena de a janela congelar. Mas ela pode suspender o quanto quiser: uma corrotina de [Dispatchers.Main] que está esperando um [await()] ou um [delay] devolve a thread à biblioteca gráfica, que continua a processar os eventos.
9.11.3. Concluindo uma operação manualmente: CompletableDeferred
Às vezes pode ser necessário usar uma API que sinaliza seus eventos por meio de listeners (Capítulo 7), enquanto o restante do código é escrito com corrotinas. O Kotlinx.coroutines oferece duas ferramentas para isso:
- A classe [CompletableDeferred<T>], o equivalente de [CompletableFuture], que você mesmo conclui: trata-se de um [Deferred<T>] “pendente”, que você entrega imediatamente e conclui depois, no momento oportuno, com [complete(value)] (sucesso), [completeExceptionally(exception)] (falha) ou [cancel()] (cancelamento). Como em [CompletableFuture], quem o concluir primeiro vence: as chamadas seguintes não têm efeito ([complete] e [completeExceptionally] passam então a retornar [false]);
- a função [suspendCancellableCoroutine], já usada nos programas [Async02.kt] e [Async21.kt], que transforma o evento esperado em uma função de suspensão cancelável.
O programa [Async28.kt] reimplementa o programa Java que esperava um termômetro — que notifica seus listeners a cada medição — atingir certa temperatura:
Resultados:
Comentários:
- Linhas 75–93: o termômetro, uma classe “à moda antiga”: um [ScheduledExecutorService] aumenta a temperatura em 0,5 °C a cada 200 ms e a transmite a seus listeners, do tipo [(Double) -> Unit]. A lista de listeners é uma [CopyOnWriteArrayList], uma lista que pode ser modificada por uma thread (adição ou remoção de um listener) enquanto outra thread a percorre. A propriedade [nbListeners] permitirá verificar se os listeners foram removidos corretamente;
- Linhas 46–56: a função que converte notificações em [Deferred]. Ela cria um [CompletableDeferred<Double>] temporário, registra um listener no termômetro e retorna imediatamente o [CompletableDeferred] (tratado como um [Deferred<Double>]: o chamador não pode concluí-lo por conta própria), que ainda não está concluído;
- linhas 49–50: a cada medição, o listener testa o limite. Quando ele é atingido, conclui o [CompletableDeferred] com a temperatura como resultado. As medições seguintes ainda chamariam [complete], sem efeito, até que o listener seja removido;
- linha 54: qualquer que seja a forma como o [Deferred] termine (limite atingido, falha, cancelamento), a ação registrada por [invokeOnCompletion] remove o listener: é o [whenComplete] do programa Java. Sem isso, um listener cujo limite nunca fosse atingido permaneceria registrado indefinidamente;
- linhas 24–26: para o chamador, esperar por uma temperatura é uma operação assíncrona como qualquer outra: ele a espera com [await()]. Uma vez atingido o limite, o listener foi removido (linha 6 dos resultados: 0 listeners);
- linhas 28–34: uma diferença significativa em relação ao programa Java, em que [orTimeout] concluía [CompletableFuture] por conta própria. Aqui, [withTimeoutOrNull] cancela o bloco de espera ([await()]), e não o [Deferred] esperado: após 600 ms, a espera é abandonada ([null]), mas a operação continua, e seu listener ainda está registrado (linha 10 dos resultados: 1 listener). Um [CompletableDeferred] não é filho de nenhuma corrotina: a concorrência estruturada não se aplica a ele, e cabe ao seu criador cancelá-lo com [cancel()], o que remove o listener (linha 11);
- Linhas 60–71: a mesma espera, escrita como uma função de suspensão com [suspendCancellableCoroutine]. O listener retoma a corrotina com a temperatura ([resume]) depois de se remover. Como precisa se referir a si mesmo, ele é declarado com [lateinit var] antes de ser inicializado: uma lambda não pode referenciar a variável à qual está sendo atribuída. O teste [continuation.isActive] impede que a continuação seja retomada duas vezes (o que dispararia uma [IllegalStateException]). [invokeOnCancellation] registra a ação a ser realizada se a corrotina for cancelada enquanto espera: a remoção do listener;
- Linhas 36–40: desta vez, [withTimeout] cancela a corrotina suspensa em [temperatureReached]: a ação [invokeOnCancellation] remove o listener, e não há mais nada a fazer (linha 15: 0 listeners).
Preferimos, portanto, a segunda forma: uma função de suspensão construída com [suspendCancellableCoroutine] participa do cancelamento e da concorrência estruturada, ao passo que um [CompletableDeferred] é um objeto independente que seu criador deve se lembrar de concluir em todos os casos. O [CompletableDeferred] continua útil para um valor esperado por várias corrotinas (um sinal de partida, por exemplo) ou para um resultado fornecido por uma corrotina a outra. Uma precaução, a mesma do Java: o listener é executado pela thread do termômetro, no meio das notificações a seus listeners; ele deve ser mantido curto. É o caso aqui: [complete] e [resume] apenas delegam ao seu dispatcher a retomada da corrotina (a thread principal, a de [runBlocking]).
9.12. Paralelismo limitado
9.12.1. Semaphore e limitedParallelism
[awaitAll] e uma corrotina por operação lançam todas as operações simultaneamente. Isso nem sempre é desejável: para baixar 10.000 páginas web, você não quer abrir 10.000 conexões simultâneas com o mesmo servidor. Como as threads virtuais, as corrotinas não são mantidas em pool (são tão baratas que se lança uma por tarefa): o que se limita é o acesso ao recurso escasso. O Kotlinx.coroutines oferece duas ferramentas para isso:
- um semáforo de corrotinas, a classe [Semaphore] do pacote [kotlinx.coroutines.sync] (não confundir com a de [java.util.concurrent], apresentada no Capítulo 8): suas permissões representam o número de operações simultâneas permitidas; uma corrotina que espera por uma permissão fica suspensa, sem bloquear nenhuma thread;
- uma visão limitada de um dispatcher, [dispatcher.limitedParallelism(n)], registrada com o programa [Async09.kt]: um dispatcher que usa as threads do dispatcher original, mas nunca mais de [n] ao mesmo tempo.
O programa [Async29.kt] retoma o programa Java que baixava nove páginas — no máximo três por vez — e depois compara as duas ferramentas:
Resultados:
Comentários:
- linha 23: um semáforo de corrotinas com 3 permissões;
- linhas 24–33: uma corrotina por página. O bloco [coroutineScope] espera o término das nove corrotinas, de forma semelhante ao método [close()] do executor do programa Java;
- linha 29: cada corrotina espera por uma permissão, baixa sua página e depois devolve a permissão. A função [withPermit] faz tudo isso: ela obtém uma permissão ([acquire()], uma função de suspensão), executa o bloco e devolve a permissão ([release()]) em um [finally], de modo que ela seja devolvida mesmo que o bloco falhe ou a corrotina seja cancelada. O programa Java precisava escrever ele mesmo o [try / finally] e tratar a [InterruptedException] de [acquire];
- linhas 58–65: o download simulado de uma página, uma função de suspensão que espera um segundo. O contador [inProgress], compartilhado pelas corrotinas, é um [AtomicInteger]: as corrotinas lançadas por [runBlocking] são executadas aqui em uma única thread, mas as das Partes 2 e 3 são executadas em várias threads. O contador [maximum] registra o maior número de downloads simultâneos: [accumulateAndGet(n, ::maxOf)] o substitui atomicamente pelo maior entre seu próprio valor e o de [n] (a função da biblioteca padrão [maxOf], passada por referência);
- Os resultados da Parte 1 mostram três ondas de três páginas: assim que uma página termina, outra começa, e o número de downloads ativos nunca passa de 3. O processo inteiro leva 3 segundos em vez de 9. Essas nove corrotinas foram executadas por uma única thread, a de [runBlocking];
- Linhas 35–43: [Dispatchers.IO.limitedParallelism(3)] é uma visão do dispatcher [IO] limitada a 3 threads. As nove corrotinas são lançadas nessa visão e executam um download bloqueante ([Thread.sleep]): apenas três podem executar por vez; as outras esperam que uma thread fique disponível. O processo inteiro leva 3 segundos, com no máximo 3 downloads em andamento (linha 21 dos resultados). Essa é a ferramenta certa para limitar uma tarefa bloqueante (uma biblioteca JDBC, arquivos) ou um cálculo: uma visão de [Dispatchers.IO] gerada por [limitedParallelism] pode inclusive exceder o limite de 64 threads de [Dispatchers.IO], o que permite atribuir a cada recurso bloqueante sua própria cota de threads (por exemplo, tantas quanto as conexões de um pool de conexões de banco de dados);
- linhas 46–53: a mesma visão, com o download em pausa ([delay]). Desta vez, os nove downloads ocorrem simultaneamente, e o processo inteiro leva um segundo (linha 22). [limitedParallelism] limita o número de corrotinas em execução ao mesmo tempo — isto é, o número de threads ocupadas; uma corrotina suspensa não ocupa uma thread e não é contada. Para limitar o número de operações em andamento (conexões, consultas), é preciso, portanto, usar o semáforo.
Ponto principal: limitedParallelism limita threads; o semáforo limita operações.
9.12.2. Produtores/consumidores: workers lendo um canal
O capítulo anterior apresentou o modelo produtor/consumidor com uma [BlockingQueue], e o curso de Java o implementou com threads virtuais. Com corrotinas, a ferramenta é o canal: [send] substitui [put], o laço [for] sobre o canal substitui as sucessivas chamadas a [take] e [trySend] substitui [offer] (uma tentativa não bloqueante). Várias corrotinas que leem o mesmo canal dividem seus valores: essa é outra forma de limitar o paralelismo, lançando um número fixo de “workers” que processam as tarefas uma após a outra. O programa [Async30.kt] tem pedidos — gerados a cada 50 ms — processados por dois consumidores, cada um dos quais leva 400 ms para processar um pedido:
Resultados:
Comentários:
- linha 17: um canal com capacidade 2: ele contém no máximo 2 pedidos pendentes;
- linhas 18–21: o produtor e os dois consumidores são três corrotinas filhas do bloco [coroutineScope], que espera o término das três;
- linhas 27–42: o produtor recebe o canal como um [SendChannel<Int>], a parte “enviar” do canal: ele só pode enviar. Ele tenta depositar cada pedido com [trySend], que nunca suspende e retorna um [ChannelResult] cuja propriedade [isSuccess] indica se o valor foi depositado. Se o canal está cheio, ele sinaliza isso e espera por espaço com [send]: o produtor é freado para acompanhar o ritmo dos consumidores (linhas 8–10 dos resultados). Esse é o benefício de um canal limitado: um produtor rápido demais não consegue encher a memória;
- linha 41: a produção terminou; o produtor fecha o canal. O programa Java precisava colocar um valor específico — o marcador de fim — que cada consumidor reconhecia e devolvia à fila para o seguinte; um canal, em contrapartida, sabe quando está fechado. Fechar o canal não exige espaço no canal: o fim da produção é sinalizado assim que o último pedido é colocado (linha 18), ao passo que, em Java, a colocação do marcador de fim precisava esperar por uma vaga livre;
- linhas 46–54: os consumidores são lançados por uma função de extensão de [CoroutineScope] (programa [Async25.kt]), cujo parâmetro [vararg names] (Capítulo 3) aceita qualquer número de nomes. Cada worker percorre o canal com um laço [for], que termina quando o canal está fechado e vazio. Um pedido é entregue a apenas um worker: os pedidos são distribuídos entre C1 e C2 conforme a disponibilidade deles;
- duas linhas exibidas quase ao mesmo tempo podem aparecer em uma ordem que varia de uma execução para outra.
Para processar uma lista conhecida de antemão com [n] workers, enviamos os elementos a um canal, o fechamos e lançamos [n] corrotinas para lê-lo: ao contrário de um semáforo, que lança uma corrotina por elemento, essa abordagem lança apenas [n] corrotinas, o que faz diferença quando se lida com milhões de elementos.
9.13. Tempo
Quando se trata de tempo em corrotinas, a primeira função a considerar é [delay]: uma espera que não bloqueia uma thread, é cancelável e aceita um número de milissegundos ou uma duração ([Duration]: [delay(500.milliseconds)]). As funções [withTimeout] e [withTimeoutOrNull] (programa [Async19.kt]) limitam a duração de um bloco. Com essas duas ferramentas, escrever um temporizador é simples: uma corrotina que faz um laço esperando entre duas ações e que é interrompida por cancelamento. O curso de Java usava um [ScheduledExecutorService] para isso; o programa [Async31.kt] implementa os dois tipos de temporizadores periódicos com corrotinas e depois reutiliza a classe [Reception] do programa Java, que depende da hora:
Resultados:
Comentários:
- linha 18: para medir uma duração, usamos aqui o cronômetro monotônico da biblioteca padrão do Kotlin: [TimeSource.Monotonic.markNow()] retorna uma marca de tempo do instante atual, e [start.elapsedNow()] retorna a duração ([Duration]) decorrida desde então. Isso equivale a [System.nanoTime()], que usamos até agora, mas com durações tipadas;
- linhas 20–31: uma ação a cada 500 ms, executada por uma corrotina que faz um laço indefinidamente ([while (true)]). O laço não oferece risco: cada [delay] é um ponto de cancelamento. Após 2,2 segundos, a corrotina principal a cancela e espera que ela termine ([cancelAndJoin()]). A variável [nbTicks] é uma simples variável local ([var]), modificada pela lambda de [launch]: o Kotlin permite que um closure modifique uma variável capturada (Capítulo 7), ao passo que o Java exigia um [AtomicInteger]; isso é seguro aqui porque todas as corrotinas são executadas na única thread de [runBlocking];
- esse primeiro temporizador espera 500 ms depois de cada ação, que por sua vez dura 100 ms: o temporizador dispara a cada 600 ms (linhas 2–4 dos resultados; o primeiro intervalo é um pouco mais longo, enquanto as classes são carregadas). Esse é o comportamento do método [scheduleWithFixedDelay] de um [ScheduledExecutorService]: um atraso fixo entre o fim de uma execução e o início da seguinte;
- linhas 38–46: o segundo temporizador é configurado para intervalos fixos: 500, 1.000, 1.500, 2.000 ms (linhas 6–9), independentemente da duração da ação. A variável [next] é a marca de tempo do próximo disparo ([start + 500.milliseconds]: uma marca de tempo mais uma duração resulta em uma marca de tempo). [next.elapsedNow()] é negativo enquanto esse instante está no futuro: [delay(-next.elapsedNow())] espera, portanto, o tempo restante (um atraso negativo ou zero não causa espera). Esse é o comportamento de [scheduleAtFixedRate]. O Kotlinx.coroutines não tem uma função de temporizador embutida que seja estável (a função [ticker] está marcada como obsoleta): o laço é a abordagem recomendada;
- linhas 63–68: a classe [Reception] diz “Olá” ou “Boa noite” conforme a hora. Ela recebe seu relógio, um [java.time.Clock], em seu construtor, em vez de chamar [LocalDateTime.now()]: trata-se de uma dependência injetada, assim como a camada [dao] é injetada na camada [business] no Capítulo 6. [now.hour] é a chamada ao método Java [getHour()], tratado como uma propriedade;
- linhas 55–59: [Clock.fixed(instant, zone)] retorna um relógio parado, que sempre devolve o mesmo horário: isso permite verificar o comportamento de [Reception] pela manhã e à noite sem precisar esperar até a noite. A última linha usa o relógio do sistema: o resultado, portanto, depende do horário de execução.
A título de lembrança, o [ScheduledExecutorService] do curso de Java ainda pode ser usado em Kotlin (o termômetro do programa [Async28.kt] usa um), mas suas tarefas são [Runnable]s executados por threads próprias, fora de qualquer corrotina. Em um programa baseado em corrotinas, é preferível usar uma corrotina e [delay], que terminam junto com seu escopo.
As funções de temporização das corrotinas têm outra vantagem, particularmente importante para testes: o módulo [kotlinx-coroutines-test] fornece uma função, [runTest], que executa as corrotinas usando tempo virtual: as funções [delay] não esperam de fato; o relógio virtual avança instantaneamente, e um teste que simula uma espera de um minuto leva apenas alguns milissegundos.
9.14. Corrotinas e threads virtuais
O curso de Java concluiu este capítulo com uma visão geral da concorrência estruturada, que trata um grupo de subtarefas como um bloco: elas são lançadas dentro de um escopo, o escopo espera que terminem e, se uma falha, as demais são abortadas. Em Kotlin, isso não é apenas uma visão geral: é a própria base das corrotinas, apresentada no início deste capítulo ([coroutineScope], [supervisorScope], programa [Async11.kt]) e usada em todos os exemplos desde então. É interessante comparar as duas linguagens, já que Java caminha na mesma direção.
9.14.1. StructuredTaskScope (Java) e coroutineScope (Kotlin)
A classe Java [StructuredTaskScope] implementa a concorrência estruturada usando threads virtuais. Ela está disponível desde o Java 21, mas ainda tem o status de “preview” no Java 25: sua API ainda pode mudar, e um programa que a utilize deve ser compilado e executado com a opção [--enable-preview]. Eis o código apresentado no curso de Java (arquivo [preview/StructuredConcurrency.txt] na pasta [09-async] do curso de Java):
Resultados (execução com o JDK 25):
[StructuredTaskScope.open()] abre um escopo declarado em um [try] com recurso; [fork] lança uma subtarefa em uma nova thread virtual; [join()] espera que todas as subtarefas terminem e, se alguma falhar, encerra as demais e lança uma exceção; um [Joiner] escolhe uma política diferente, como “a primeira subtarefa que for bem-sucedida retorna o resultado”. O programa [Async32.kt] faz o mesmo com corrotinas e, em seguida, demonstra que as corrotinas também podem lidar com código bloqueante executado por threads virtuais:
Resultados:
Comentários:
- linhas 19–23: o bloco [coroutineScope] age como um escopo Java: as duas subtarefas lançadas por [async] são suas filhas; ele só termina quando elas terminam e, se uma falha, a outra é abortada e a exceção é relançada. O bloco retorna um par ([to], Capítulo 3), desempacotado por uma atribuição por desestruturação. A duração do conjunto é a da subtarefa mais longa, um segundo (linha 2 dos resultados). Não há [try] com recurso, nem [join()] ou [Subtask.get()]: o escopo é um bloco de código, e o resultado de uma subtarefa é o resultado de [await()];
- linhas 27–33: a política “a primeira resposta basta” é implementada usando [select] (programa [Async13.kt]), que espera a primeira subtarefa concluída e depois cancela todas as outras (cancelar uma corrotina concluída não tem efeito). Sem esses cancelamentos, o bloco [coroutineScope] esperaria o espelho de Paris terminar. A resposta chega após 300 ms (linha 3);
- linhas 37–45: desta vez, as subtarefas executam código bloqueante ([Thread.sleep]) em um dispatcher cujas threads são threads virtuais (programa [Async09.kt]). A função [runInterruptible] (programa [Async19.kt]) converte o cancelamento da corrotina em uma interrupção da thread que executa o código bloqueante. A segunda subtarefa falha após 200 ms ([require] lança uma [IllegalArgumentException]); o escopo então cancela a primeira, e [runInterruptible] interrompe sua thread virtual, cujo [Thread.sleep] lança uma [InterruptedException] (linha 4 da saída: a thread que exibe a mensagem é uma [VirtualThread], montada em uma thread portadora do [ForkJoinPool]). A exceção original é então lançada por [coroutineScope] (linha 5). É exatamente assim que [StructuredTaskScope] se comporta: a concorrência estruturada de Kotlin também se aplica ao código bloqueante;
- o dispatcher de threads virtuais é fechado por [use] ao final do bloco, o que encerra seu executor.
9.14.2. Quando escolher um ou outro?
Threads virtuais e corrotinas resolvem o mesmo problema: escrever, de forma sequencial e legível, código que espera muito (por E/S), sem bloquear uma thread do sistema durante a espera. Elas o fazem de duas maneiras opostas:
Threads virtuais (Java 21) | Corrotinas (Kotlin) | |
Onde está o mecanismo | na JVM: a pilha da thread virtual é copiada para o heap durante uma espera | no compilador e em uma biblioteca: uma função [suspend] é transformada em uma máquina de estados |
O que suspende | qualquer operação bloqueante do JDK ([Thread.sleep], sockets, [BlockingQueue], locks) | somente as funções de suspensão ([delay], [await], [send]…); o código bloqueante deve ser tratado pelo o dispatcher [IO] |
Código existente | inalterado: qualquer biblioteca bloqueante (JDBC, cliente HTTP) se beneficia disso sem modificação | São necessárias versões [suspend] da API, ou adaptadores ([await()], [withContext(Dispatchers.IO)]) |
Marcação no código | Nenhuma: um método bloqueante parece igual a qualquer outro | A palavra-chave [suspend] identifica as funções que podem esperar (as chamadas “funções coloridas”) |
concorrência estruturada | [StructuredTaskScope], ainda em preview no Java 25 | [coroutineScope], [supervisorScope], [Job]: estável desde 2018, no centro do modelo |
cancelamento | interrupção de thread ([Thread.interrupt]), à qual cada biblioteca reage à sua maneira | cancelamento cooperativo, propagado pela árvore de corrotinas, com [CancellationException], [withTimeout], [NonCancellable] |
fluxos de valores, canais | [Stream] bloqueantes, [BlockingQueue], [java.util.concurrent.Flow] | [Flow], [Channel], [SharedFlow], [StateFlow], com seus operadores |
escolha da thread | nenhuma: uma thread virtual executa em qualquer portadora | dispatchers ([Main], [Default], [IO], [limitedParallelism]) |
plataformas | JVM (21 em diante) | JVM, Android (todas as versões), JavaScript, nativo (Kotlin Multiplatform) |
Custo de uma tarefa pendente | algumas centenas de bytes a alguns KB (a pilha copiada) | algumas dezenas a algumas centenas de bytes (o objeto de continuação) |
Não se trata de escolher um em vez do outro: eles podem ser combinados, como mostra a Parte 3 do programa [Async32.kt]. Alguns pontos de referência:
- Para um programa Kotlin que orquestra operações assíncronas (lançar, esperar, combinar, limitar, cancelar e difundir valores), as corrotinas são a escolha natural: elas oferecem concorrência estruturada, cancelamento, fluxos e dispatchers, recursos que as threads virtuais sozinhas não oferecem (ou ainda não oferecem);
- Para código bloqueante que não pode ser reescrito (um driver JDBC, uma biblioteca Java que faz E/S bloqueante), as threads virtuais evitam que as 64 threads do dispatcher [IO] se esgotem: elas são usadas como dispatcher ([Executors.newVirtualThreadPerTaskExecutor().asCoroutineDispatcher()]) ou diretamente, em um servidor que processa cada requisição em uma thread virtual (o Spring Boot pode fazer isso);
- no Android, ou em código Kotlin Multiplatform, só há corrotinas disponíveis;
- o código Java que chama código Kotlin não pode chamar diretamente uma função de suspensão: em vez disso, recebe uma função comum que retorna um [CompletableFuture] (usando a função [future { … }] do programa [Async04.kt]) ou uma função bloqueante (usando [runBlocking]) que o Java chamará em uma thread virtual.
9.15. Aplicação: cálculo do imposto com corrotinas
O programa [Async33.kt] reúne várias ferramentas deste capítulo relacionadas ao cálculo do imposto tratado no fio condutor. Como o programa Java, ele é autônomo (não usa as camadas da Versão 5 do Capítulo 6): lê as faixas do imposto no arquivo [TaxData.txt], já utilizado, e lê uma lista de contribuintes no arquivo [taxpayers.txt], também localizado na raiz do projeto:
(cada linha contém: casado [y/n], número de filhos, salário anual), calcula o imposto de cada contribuinte e grava os resultados no arquivo [results.txt]. As duas leituras são realizadas simultaneamente por duas corrotinas, e todo o processamento é limitado a 10 segundos. Em seguida, o programa calcula os impostos de um milhão de contribuintes imaginários, primeiro de forma sequencial e depois em paralelo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | |
Resultados:
O mesmo programa, com o nome de um arquivo de faixas inexistente como argumento (a opção [--args] da tarefa Gradle [run] repassa seus argumentos ao programa):
Comentários:
- linhas 72–75: o processamento é uma função de suspensão cujo corpo é um bloco [coroutineScope]. Os dois arquivos de entrada são lidos simultaneamente por duas corrotinas lançadas por [async] no dispatcher [IO], usando funções de leitura bloqueantes comuns ([useLines], [readLines]); o cálculo espera as duas leituras com [await()]. O programa Java precisava lançar o cálculo como uma terceira tarefa, que bloquearia uma thread virtual enquanto esperasse as duas leituras; aqui, o cálculo é simplesmente a continuação do código;
- linhas 35–42: o programa principal limita o processamento a 10 segundos usando [withTimeout]. Passado esse prazo, o processamento seria cancelado, isto é, as duas leituras e o cálculo, sem exigir nenhum código adicional: isso é concorrência estruturada. A expressão [return@runBlocking] sai da lambda de [runBlocking] e, portanto, do programa (Capítulo 7: um [return] com rótulo);
- linhas 44–46: os erros são tratados em um único lugar, no programa principal. Um erro de leitura (arquivo ausente, número incorreto) faz a corrotina de leitura falhar; o bloco [coroutineScope] então cancela a outra leitura e relança a exceção original, que chega sem alterações ao [catch] (segundo resultado). O programa Java recebia essa exceção encapsulada duas vezes em uma [ExecutionException] e precisava desencapsulá-la em um laço: a concorrência estruturada eliminou esse inconveniente, como explicado no curso de Java;
- linha 33: o nome do arquivo de faixas é o primeiro argumento do programa, se houver; caso contrário, [getOrElse] retorna o valor calculado pela lambda;
- linhas 79–80: leitura das faixas, usando a sequência de linhas do arquivo ([useLines]), que ignora as linhas vazias;
- linhas 83–97: processamento dos contribuintes, que grava em um arquivo; ele, portanto, transfere a si mesmo ao dispatcher [IO], conforme a regra definida pelo programa [Async21.kt]. Cada linha é validada pela expressão regular da linha 29: um [y] ou um [n], seguido de dois inteiros positivos separados por espaços ([\s+]); a raw string (["""…"""]) evita que as barras invertidas sejam duplicadas. [matchEntire] retorna o resultado da correspondência se a linha inteira casar com a expressão, [null] caso contrário; sua propriedade [destructured] permite recuperar os três grupos por uma atribuição por desestruturação, em [let]. O operador Elvis ([?:]) retorna o texto “incorrect line” quando a linha não corresponde ([x] em vez de [y/n], salário negativo);
- linhas 101–109: o cálculo do imposto, em [BigDecimal], escrito com os operadores [+], [*], [-], e [<=], que Kotlin permite para esse tipo. A divisão da renda pelo número de partes pode não ser exata: ela é feita com [divide] com precisão de 16 dígitos significativos ([MathContext.DECIMAL64]), e não com o operador [/], que arredondaria o quociente para o número de casas decimais do dividendo. A primeira faixa cujo limite é maior ou igual ao quociente familiar é encontrada com [firstOrNull], e o operador Elvis retorna a última faixa se nenhuma das outras servir. [toInt()] trunca o imposto para o euro inteiro. O contribuinte é uma data class, decomposta por uma declaração de desestruturação;
- os resultados fornecem os valores de controle do fio condutor: 4.282 € para um casal com 2 filhos e salário de 60.000 €, 2.959 € com 3 filhos e 11.519 € para uma pessoa solteira sem filhos;
- linhas 50–68: um milhão de contribuintes fictícios são gerados por um gerador de números pseudoaleatórios ([Random]) cuja semente fixa (2026) garante resultados reproduzíveis. Seus impostos são primeiro somados em sequência ([sumOf], depois [Long] para evitar que o [Int] estoure a capacidade). Em seguida, são divididos em tantos pacotes ([chunked]) quantos processadores a máquina tem; cada pacote é atribuído a uma corrotina do dispatcher [Default], que tem tantas threads quantos processadores, e [awaitAll()] calcula as somas parciais. O total é o mesmo, e o cálculo é mais rápido nesta máquina de dois processadores (o ganho aparente é até maior que 2, porque a primeira medição inclui o tempo que a JVM leva para compilar o código do cálculo em código de máquina).
Calcular o imposto de um contribuinte é síncrono: não envolve E/S e leva alguns microssegundos. Seria inútil, e até prejudicial, torná-lo uma função suspensível ou delegá-lo a outra thread: somente as tarefas que envolvem espera devem ser tornadas assíncronas. Por outro lado, um grande número de cálculos independentes pode ser distribuído entre os processadores: esse é o papel do dispatcher [Default] (ou dos streams paralelos tratados no Capítulo 8), e não o do dispatcher [IO] nem o das threads virtuais, que lidam com operações de espera.
9.16. As regras de ouro
Vamos resumir as regras da programação assíncrona com corrotinas:
- Para esperar, suspenda; não bloqueie: em uma corrotina, a espera é feita por uma função de suspensão ([delay], [await()], [send], [receive], [withContext]…), nunca por [Thread.sleep], [join()] ou [get()] de um [Future]. [runBlocking] só tem lugar no programa principal e nos testes;
- uma função de suspensão bloqueante transfere ela mesma o controle ao dispatcher correto: o código bloqueante (arquivos, JDBC, bibliotecas Java) é entregue a [Dispatchers.IO] por [withContext(Dispatchers.IO)], dentro da função bloqueante; o chamador pode então chamá-la de qualquer lugar. Uma API que retorna um [CompletableFuture] é combinada com [await()]; uma API baseada em callbacks é combinada com [suspendCancellableCoroutine];
- Dispatchers.Default para cálculos, Dispatchers.IO para esperas bloqueantes, Dispatchers.Main para a interface; uma visão [limitedParallelism(n)] para reservar um número de threads para um recurso bloqueante; threads virtuais atuando como dispatcher quando há milhares de esperas bloqueantes;
- toda corrotina tem um pai: as corrotinas são lançadas dentro de um escopo ([coroutineScope], o escopo de um componente, [viewModelScope]…), nunca em [GlobalScope]; um escopo espera seus filhos; se um filho falha, os outros são cancelados ([supervisorScope] para torná-los independentes), e cancelar um pai cancela seus filhos. Uma função que lança corrotinas sem esperá-las é uma extensão de [CoroutineScope]; uma função que espera o término de seu trabalho é uma função [suspend];
- lance primeiro, espere depois: para executar várias operações independentes simultaneamente, lance todas ([async]) e depois espere por elas ([awaitAll()]);
- o cancelamento é cooperativo: uma corrotina para em seus pontos de suspensão; um cálculo longo verifica [isActive] ou chama [ensureActive()] / [yield()]; uma [CancellationException] nunca é engolida (cuidado com [catch (e: Exception)] e [runCatching]); a limpeza de uma corrotina cancelada que precise suspender é feita em [withContext(NonCancellable)];
- Limite os tempos de espera: [withTimeout] e [withTimeoutOrNull] cancelam a própria operação, e não apenas a espera; um [CompletableDeferred] com timeout deve ser cancelado por seu criador;
- Limite as operações concorrentes usando um semáforo ([withPermit]) ou um número fixo de workers que leem um [Channel]; [limitedParallelism] limita threads, não operações suspensas;
- Uma sequência de valores é um Flow: frio, coletado sob demanda, transformado por operadores; [flowOn] para mudar o dispatcher do produtor, [buffer] para desacoplar produtor e consumidor, [catch] para erros a montante. As fontes quentes são [Channel] (um consumidor por valor), [SharedFlow] (todos os assinantes) ou [StateFlow] (um estado);
- Nenhum lock de thread em torno de uma suspensão: [synchronized] e [ReentrantLock] não devem envolver uma chamada de suspensão; use um [Mutex]ou, melhor ainda, evite o estado compartilhado (um [Deferred] compartilhado, um canal, dados imutáveis).
A tabela a seguir resume as equivalências entre o mundo das threads de plataforma e das esperas bloqueantes (capítulo anterior), o das threads virtuais e do [CompletableFuture] (curso de Java) e o das corrotinas:
Threads, esperas bloqueantes | Threads virtuais, CompletableFuture | Corrotinas |
[Thread.sleep(1000)] (bloqueia a thread) | [Thread.sleep(1000)] em uma thread virtual (libera a portadora) | [delay(1000)] (suspende a corrotina) |
[thread { … }] seguido de [join()] | [executor.submit { … }] depois [get()]; [supplyAsync { … }] depois [join()] | [launch { … }] seguido de [join()]; [async { … }] seguido de [await()] |
Esperar várias threads ([join] em um laço) | [invokeAll(...)], [allOf(...)], [anyOf(...)] | [awaitAll()], [coroutineScope], [select] |
Métodos de callback ([CompletionHandler]) | [thenApply], [thenCompose], [thenCombine] | O código que segue a chamada de suspensão |
[try / catch] em torno de [get()] ([ExecutionException]) | [exceptionally], [handle], [whenComplete] | [try / catch] (comum), [CoroutineExceptionHandler] |
[thread.interrupt()] | [future.cancel(true)] | [job.cancel()] (cancelamento cooperativo, propagado aos filhos) |
[future.get(timeout, unit)] | [orTimeout(...)], [completeOnTimeout(...)] | [withTimeout(...)], [withTimeoutOrNull(...)] |
pool de threads de tamanho fixo | [Semaphore] ([java.util.concurrent]) | [Semaphore] ([kotlinx.coroutines.sync]), [limitedParallelism(n)] |
[BlockingQueue] (bloqueia a thread) | [BlockingQueue] em threads virtuais, [SubmissionPublisher] | [Channel], [SharedFlow] |
[Stream], [Iterator] | [Stream], um lock lido por uma thread virtual | [Flow] |
[synchronized], [ReentrantLock] | [ReentrantLock] | [Mutex] |
[ScheduledExecutorService] | [ScheduledExecutorService], [delayedExecutor] | [delay] em um laço |
— | [new CompletableFuture<>()], [complete] | [CompletableDeferred], [suspendCancellableCoroutine] |
— | [StructuredTaskScope] (preview) | [coroutineScope], [supervisorScope] |
Os capítulos seguintes aplicarão essas regras: o acesso a bancos de dados com JDBC (Capítulo 10) e Hibernate (Capítulo 11), em que as chamadas de API são bloqueantes e são usadas a partir de corrotinas no dispatcher [IO] (ou em threads virtuais), o servidor TCP, que atende cada cliente por meio de uma thread virtual ou de uma corrotina, e o cliente [HttpClient] (Capítulo 12), bem como os serviços web Spring Boot e seus clientes (Capítulo 13).