Skip to content

8. Threads de execução

Este capítulo apresenta a execução simultânea de vários trechos de código dentro de um mesmo programa: as threads (threads de execução) e as ferramentas usadas para sincronizá-las. Há cerca de vinte anos, a maioria das máquinas tinha apenas um processador, e o paralelismo era em grande parte uma ilusão mantida pelo sistema operacional. Hoje, até o laptop mais básico tem vários núcleos: várias threads realmente executam ao mesmo tempo, o que torna ainda mais frequentes os problemas de sincronização discutidos aqui.

Kotlin não tem threads próprias na JVM: ela usa as threads de Java, que foram integradas a Java desde a sua primeira versão (1996) por meio da classe [Thread], da palavra-chave [synchronized], e dos métodos [wait] e [notify] da classe [Object]. Java 5 (2004) acrescentou o pacote [java.util.concurrent] e seus subpacotes [java.util.concurrent.locks] e [java.util.concurrent.atomic]: locks, semáforos, coleções concorrentes, pools de threads etc. Java 7 acrescentou o framework [Fork/Join], Java 8 introduziu os streams paralelos, e Java 21 introduziu as threads virtuais, todos eles mudando profundamente a maneira de escrever servidores. Java 25 introduz, por fim, os valores vinculados a um escopo ([ScopedValue]). Todas essas classes do JDK são diretamente utilizáveis em Kotlin: esse é um de seus grandes pontos fortes. A biblioteca padrão de Kotlin acrescenta algumas funções que tornam o uso mais cômodo: a função [thread] e a função de extensão [withLock] do pacote [kotlin.concurrent], a função [synchronized] e as anotações [@Volatile] e [@Synchronized] … Veremos todas essas ferramentas neste capítulo.

No entanto, as threads não são a última palavra de Kotlin em programação concorrente: sua solução nativa para a assincronia são as corrotinas, apresentadas no Capítulo 9. Elas se baseiam em threads, e tudo o que veremos aqui (seções críticas, visibilidade de escrita, deadlocks etc.) continua essencial para compreendê-las por completo.

Os exemplos estão no projeto Gradle [08-threads]. Cada programa é um arquivo situado em um pacote que leva seu nome ([threads01/Threads01.kt] no pacote [threads01]…) e é executado por [gradlew -q run -Pmain=threads01.Threads01Kt], ou pelo triângulo verde do IntelliJ IDEA. Os eventuais argumentos do programa são passados ao Gradle com a opção [--args]: [gradlew -q run -Pmain=threads08.Threads08Kt --args="5"].

Um aviso antes de começar: os resultados de um programa multithread variam de uma execução para outra. A ordem em que as threads obtêm acesso ao processador depende do sistema operacional, do número de processadores e da carga da máquina. Os resultados reproduzidos neste capítulo foram obtidos em uma máquina Linux de dois processadores, compartilhada com outros programas muito ativos. Se você executar os exemplos, obterá resultados semelhantes, mas raramente idênticos. Indicaremos, em cada caso, o que é reproduzível e o que não é.

8.1. A classe Thread

Quando uma aplicação é iniciada, ela é executada em um fluxo de execução chamado thread. A classe que modela uma thread é a classe [java.lang.Thread] do pacote do JDK. Lembre-se de que Kotlin representa os acessores Java [getXxx()] / [setXxx(…)] (e [isXxx()] para um booleano) como propriedades: escrevemos [thread.name = "Main"] em vez de [thread.setName("Main")]. Os principais construtores, propriedades e métodos da classe são os seguintes:

Membro
Função
[Thread(task: Runnable)], [Thread(task: Runnable, name: String)]
cria uma thread que executará o método [run] de [task]. [Runnable] é a interface Java [void run()]: por meio da conversão SAM (Capítulo 7), passa-se a ela uma lambda [{ … }] ou uma referência de função [::f]
[thread(start, isDaemon, name, …) { … }]
(biblioteca Kotlin, pacote [kotlin.concurrent]) cria uma thread que executa a lambda, configura-a com argumentos nomeados e, por padrão, a executa imediatamente
[Thread.ofPlatform()], [Thread.ofVirtual()]
(Java 21) fornecem um "builder" para threads de plataforma ou threads virtuais, que pode ser configurado (nome, daemon etc.) antes de a thread ser criada
[Thread.currentThread()]
a thread que executa o código que chamou este método
[name]
o nome da thread (uma propriedade modificável), útil para o acompanhamento
[threadId()]
(Java 19) um identificador numérico único da thread, do tipo [Long]; ele substitui [getId()], que está obsoleto
[isDaemon]
indica (valor fixo) se a thread é uma thread daemon (veja adiante)
[priority]
a prioridade da thread, de 1 ([MIN_PRIORITY]) a 10 ([MAX_PRIORITY]), com 5 ([NORM_PRIORITY]) como padrão
[state], [isAlive]
situação da thread ([NEW], [RUNNABLE], [BLOCKED], [WAITING], [TIMED_WAITING], [TERMINATED]); [isAlive] indica se ela foi iniciada e ainda não terminou (somente leitura)
[isVirtual]
(Java 21) indica se a thread é uma thread virtual (somente leitura)
[start()]
Inicia a thread
[join()], [join(duration: Duration): Boolean]
A thread T1, que executa [T2.join()], fica bloqueada até que a thread T2 termine. A segunda forma (Java 19) limita o tempo de espera e indica se T2 terminou
[Thread.sleep(ms: Long)], [Thread.sleep(d: Duration)]
a thread que executa o método é suspensa por [ms] milissegundos (pela duração [d]). Ela perde a CPU, que é entregue a outra thread
[interrupt()], [isInterrupted]
pede à thread que se suspenda; verifica se uma suspensão foi solicitada (veja adiante)

Os métodos [join] e [sleep] lançam a exceção [InterruptedException] se a thread for interrompida durante a espera. Em Java, essa é uma exceção verificada (checked), que o compilador exige que seja tratada ou declarada em uma cláusula [throws]. Kotlin não tem exceções verificadas (Capítulo 3): o compilador não impõe nada. Isso não significa que se possa ignorar o que essa exceção significa: falaremos disso na seção sobre a interrupção de threads.

A classe [Thread] também tinha um método, [stop], que terminava uma thread à força. Ele está obsoleto desde Java 1.2 e, desde Java 20, simplesmente lança a exceção [UnsupportedOperationException]: interromper abruptamente uma thread poderia deixar os dados que ela manipulava em um estado inconsistente. Hoje, pedimos a uma thread que pare de forma cooperativa , interrompendo-a: veremos isso um pouco mais adiante.

Eis uma primeira aplicação que demonstra a existência de uma thread de execução principal — aquela que executa a função [main]. O programa [Threads01.kt] é o seguinte:

// a thread principal de um programa
package threads01

import java.time.LocalTime
import java.time.format.DateTimeFormatter

fun main() {
    // a thread que executa este código
    val main = Thread.currentThread()
    // o launcher Java lhe deu um nome
    println("Name of the current thread: [${main.name}]")
    // ele pode ser alterado
    main.name = "Main"
    println("Name of the current thread: [${main.name}]")
    // algumas propriedades
    println("Identifier (threadId): ${main.threadId()}")
    println("Daemon thread (isDaemon): ${main.isDaemon}")
    println("Virtual thread (isVirtual): ${main.isVirtual}")
    println("Priority (priority): ${main.priority}")
    println("State (state): ${main.state}")
    println("Text representation: $main")
    println("Number of processors: ${Runtime.getRuntime().availableProcessors()}")

    // uma exibição a cada segundo
    val format = DateTimeFormatter.ofPattern("HH:mm:ss")
    repeat(5) {
        println("${main.name} : ${LocalTime.now().format(format)}")
        // a thread é suspensa por 1 segundo
        Thread.sleep(1000)
    }
}

Resultados:

> gradlew -q run -Pmain=threads01.Threads01Kt
Name of the current thread: [main]
Name of the current thread: [Main]
Identifier (threadId): 3
Daemon thread (isDaemon): false
Virtual thread (isVirtual): false
Priority (priority): 5
State (state): RUNNABLE
Text representation: Thread[#3,Main,5,main]
Number of processors: 2
Main : 12:15:09
Main : 12:15:10
Main : 12:15:11
Main : 12:15:12
Main : 12:15:13

Comentários:

  • linha 9: obtém-se uma referência à thread que executa o programa;
  • Linhas 11–14: exibimos seu nome, o modificamos (uma simples atribuição à propriedade [name], que chama o método Java [setName]) e o exibimos novamente. Inicialmente, a thread principal se chama [main] (linha 1 dos resultados): o launcher Java lhe atribuiu esse nome;
  • Linhas 15–22: algumas propriedades da thread. Nesta execução, a thread principal tem o ID 3: a máquina virtual cria algumas threads para uso próprio antes de executar [main], e esse ID pode variar de uma versão de Java para outra. Ela não é uma thread daemon ([isDaemon] é igual a [false]) nem uma thread virtual (falaremos desses dois conceitos adiante); sua prioridade é a prioridade normal, 5; ela está em execução ([RUNNABLE]). O método [toString] da thread, chamado pelo template ["$main"] (linha 21), exibe seu ID, nome, prioridade e o nome de seu grupo de threads ([main]);
  • linha 22: a máquina em que o exemplo foi executado tem 2 processadores;
  • linhas 26–29: um laço que imprime uma mensagem a cada segundo. [Thread.sleep(1000)] suspende a thread principal por um segundo. Em Java, a função [main] precisava declarar a exceção verificada [InterruptedException] em uma cláusula [throws]; em Kotlin, essa exigência não existe. Observe o formato [HH:mm:ss] (horas de 0 a 23): o formato [hh] exibiria horas de 1 a 12.

8.2. Criação de threads de execução

É possível ter aplicações em que trechos de código são executados "simultaneamente" em diferentes threads de execução. Se a máquina tiver menos processadores do que threads prontas para executar, as threads compartilham os processadores: cada uma tem acesso a eles por sua vez, por um breve instante (alguns milissegundos). Em uma máquina multiprocessada, várias threads realmente executam ao mesmo tempo. O tempo concedido a uma thread depende de vários fatores, entre eles sua prioridade, que tem um valor padrão, mas pode ser definida por programa (propriedade [priority]); isso é apenas uma indicação, que o sistema operacional é livre para ignorar (Linux a ignora por padrão). Uma thread que tem acesso ao processador pode liberá-lo antes do tempo:

  • aguardando um evento (término de outra thread com [join], espera de um sinal);
  • entrando em estado de repouso por uma duração especificada ([sleep]).

Uma thread T é primeiro criada, por exemplo, pelo construtor [Thread(task, name)], em que [task] é um objeto que implementa a interface Java [Runnable], cujo único método é [void run()]. Graças à conversão SAM descrita no Capítulo 7, passa-se uma lambda ou uma referência de função do tipo [() -> Unit] no lugar de um [Runnable]. Em código mais antigo, encontramos também classes derivadas de [Thread] que redefinem seu método [run]: isso não é recomendado, pois mistura a tarefa a ser executada com o meio de executá-la.

Criar uma thread não a inicia:

  • a execução da thread T é iniciada por [T.start()]: o método [run] da tarefa passada ao construtor de T será então executado pela thread T. O código que executa a instrução [T.start()] não espera que a thread T termine: passa imediatamente à instrução seguinte. Temos agora duas threads em execução paralela. Elas muitas vezes precisam se comunicar para acompanhar o andamento do trabalho compartilhado: esse é o problema da sincronização de threads;
  • Uma vez iniciada, a thread T executa de forma autônoma. Ela termina quando a função que está executando chega ao fim;
  • podemos esperar o fim de sua execução com [T.join()]. Essa é uma instrução bloqueante: a thread que a executa fica bloqueada até que a thread T termine seu trabalho. Esse é um método básico de sincronização.

O programa [Threads02.kt] é o seguinte:

// criação de threads de execução
package threads02

import java.time.LocalTime
import java.time.format.DateTimeFormatter

fun main() {
    // a thread principal é nomeada
    Thread.currentThread().name = "Main"

    // criação de 5 threads
    val tasks = Array(5) { i ->
        // a thread nº i executará a função display; ela recebe o nome "i"
        Thread(::display, i.toString())
    }
    // sua execução é iniciada (operação não bloqueante)
    for (task in tasks) {
        task.start()
    }

    // fim da thread principal
    println("End of thread ${Thread.currentThread().name} at ${time()}")
}

// a função executada pelas threads: ela tem a forma de Runnable.run()
fun display() {
    // a thread que executa a função
    val current = Thread.currentThread()
    println("Start of execution of the display function in thread ${current.name}" +
            " (id ${current.threadId()}) : ${time()}")
    // dormir por 1 s
    sleep(1000)
    println("End of execution of the display function in thread ${current.name} : ${time()}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        // o sono foi interrompido: o flag de interrupção da thread é restaurado
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 9: a thread principal recebe um nome;
  • linhas 12–14: são criadas 5 threads. A função [Array(5) { i -> … }] cria um array de 5 elementos, em que o elemento i é o valor retornado pela lambda. As referências às threads ficam assim armazenadas em um array, para poderem ser recuperadas depois. Cada thread executa a função [display] das linhas 26–33;
  • Linha 14: a referência de função [::display], do tipo [() -> Unit], é convertida automaticamente em um objeto [Runnable]: a função [display] não tem parâmetros e não retorna resultado, exatamente como [run]. Em Java, em um arquivo-fonte compacto, seria necessário escrever [this::display]; em Kotlin, [display] é uma função de nível superior, que é designada simplesmente por [::display]. O segundo parâmetro do construtor é o nome da thread;
  • linhas 17–18: as threads são lançadas. Essa operação não é bloqueante: a thread nº i executa em paralelo com a thread principal que a lançou;
  • linha 22: a thread principal chega ao fim do programa;
  • linhas 26–33: a função [display] exibe o nome e o ID da thread que a executa, bem como os horários de início e de fim (em milissegundos) da execução;
  • linha 32: qualquer thread que execute a função [display] faz uma pausa de 1 segundo. O processador é então entregue a outra thread que o aguarda. Ao fim da pausa de 1 segundo, a thread em pausa volta a ser elegível para o processador. Ela o obterá quando chegar a sua vez;
  • Linhas 37–42: a função [sleep] encapsula [Thread.sleep]. O compilador Kotlin não exige que se capture a exceção [InterruptedException] que [sleep] pode lançar. No entanto, se ela fosse deixada escapar da função executada por uma thread, encerraria essa thread com uma mensagem de erro no console. A função [sleep] a captura, portanto, e restaura o indicador de interrupção da thread (linha 42); explicaremos essa ação na seção sobre interrupções. O nome [_] dado ao parâmetro da cláusula [catch] indica que esse parâmetro não é usado. Encontraremos essa pequena função na maioria dos programas deste capítulo;
  • linha 47: a função [time], escrita como expressão ([= …]), retorna a hora atual no formato [HH:mm:ss.SSS] ([SSS]: milissegundos).

Resultados:

> gradlew -q run -Pmain=threads02.Threads02Kt
Start of execution of the display function in thread 3 (id 24) : 12:15:14.492
Start of execution of the display function in thread 4 (id 25) : 12:15:14.492
Start of execution of the display function in thread 0 (id 21) : 12:15:14.492
Start of execution of the display function in thread 1 (id 22) : 12:15:14.491
End of thread Main at 12:15:14.490
Start of execution of the display function in thread 2 (id 23) : 12:15:14.492
End of execution of the display function in thread 3 : 12:15:15.560
End of execution of the display function in thread 1 : 12:15:15.564
End of execution of the display function in thread 2 : 12:15:15.568
End of execution of the display function in thread 0 : 12:15:15.564
End of execution of the display function in thread 4 : 12:15:15.572

Esses resultados são muito instrutivos:

  • Primeiro, vemos que o lançamento de uma thread não é bloqueante. A thread principal lançou 5 threads e chegou ao fim do programa (linha 5) mesmo que a thread 2 ainda não tivesse exibido sua primeira mensagem;
  • a ordem de execução das threads é imprevisível: nesta execução, as threads 3 e 4 exibiram suas mensagens de início antes da thread 0. O sistema operacional tem aqui 6 threads e 2 processadores; ele distribui os processadores entre essas threads segundo suas próprias regras;
  • Notamos também que a ordem das exibições nem sempre segue a ordem dos horários exibidos: a thread principal exibiu seu fim às 14.490, depois de mensagens datadas de 14.491 e 14.492. A hora é calculada antes da saída e, nesse meio-tempo, outra thread pode ter escrito no console. [println] (que chama [System.out.println]) é thread-safe: duas linhas escritas por duas threads não se misturam, mas a ordem entre elas não é garantida;
  • os IDs das threads criadas (21 a 25) mostram que a máquina virtual já havia criado cerca de vinte threads para uso próprio (coleta de lixo, compilador just-in-time etc.);
  • Cada thread faz uma pausa de um segundo com [sleep] e, em seguida, conclui a execução da função [display];
  • Por fim, o programa não parou quando a thread principal terminou seu trabalho: a máquina virtual esperou que as cinco threads terminassem. Isso ocorre porque essas threads não são threads daemon: a máquina virtual Java só para quando todas as suas threads não daemon terminaram.

Inversamente, uma thread pode ser declarada como daemon definindo a sua propriedade [isDaemon] como [true] antes de lançá-la. As threads daemon são threads de serviço que não impedem a máquina virtual de parar: quando a última thread não daemon termina, elas são interrompidas. O programa [Threads03.kt] as cria usando a função [thread] da biblioteca Kotlin:

// threads daemon - a função thread de kotlin.concurrent
package threads03

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.concurrent.thread

fun main() {
    // a thread principal é nomeada
    Thread.currentThread().name = "Main"

    // criação e início de 5 threads daemon chamadas 0, 1, 2…
    for (i in 0..<5) {
        // thread cria uma thread, a configura e (por padrão) a inicia imediatamente
        thread(isDaemon = true, name = "$i") {
            display()
        }
    }

    // as threads recebem tempo para iniciar
    sleep(100)
    // fim da thread principal, portanto do programa
    println("End of thread ${Thread.currentThread().name} at ${time()}")
}

// a função executada pelas threads
fun display() {
    val current = Thread.currentThread()
    println("Start of execution of the display function in thread ${current.name} : ${time()}")
    // dormir por 1 s
    sleep(1000)
    println("End of execution of the display function in thread ${current.name} : ${time()}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 6: a função [thread] pertence ao pacote [kotlin.concurrent] da biblioteca padrão; ela precisa ser importada;
  • Linhas 13–16: a função [thread(…) { … }] cria uma thread que executará a expressão lambda que segue os parênteses (a sintaxe da "lambda final", Capítulo 7). Todos os seus outros parâmetros têm valores padrão; os de que precisamos são definidos por argumentos nomeados: aqui, [isDaemon = true] e [name = "$i"]. Sua assinatura é a seguinte: [fun thread(start: Boolean = true, isDaemon: Boolean = false, contextClassLoader: ClassLoader? = null, name: String? = null, priority: Int = -1, block: () -> Unit): Thread]. Por padrão ([start = true]), a thread é lançada imediatamente; a função retorna a thread criada. É um substituto útil para a sequência Java [var t = new Thread(…); t.setDaemon(true); t.start();]. O intervalo [0..<5] (inteiros de 0 a 4) equivale a [0 until 5];
  • Linha 21: a thread principal espera 100 ms para dar tempo às threads de iniciarem e, em seguida, termina.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=threads03.Threads03Kt
Start of execution of the display function in thread 1 : 12:15:15.827
Start of execution of the display function in thread 2 : 12:15:15.817
Start of execution of the display function in thread 3 : 12:15:15.831
Start of execution of the display function in thread 0 : 12:15:15.832
Start of execution of the display function in thread 4 : 12:15:15.833
End of thread Main at 12:15:15.819

As 5 threads começaram a execução, e então a thread principal terminou (linha 6). Observe que sua mensagem, datada de 15.819, é exibida depois de mensagens datadas de 15.827 a 15.833: ela havia calculado a hora antes de as outras threads escreverem qualquer coisa. As threads daemon foram então interrompidas durante o período de repouso de um segundo: nenhuma mensagem de fim é exibida. Em uma máquina muito carregada, algumas threads nem têm tempo de exibir suas mensagens de início, pois 100 ms não bastam para que obtenham o processador: outra execução pode, portanto, produzir um número diferente de mensagens de início, mas nunca mensagens de fim. O mesmo efeito é obtido terminando [main] com [exitProcess(0)] (pacote [kotlin.system], que chama [System.exit(0)]), que encerra a máquina virtual e, portanto, todas as threads da aplicação, sejam daemon ou não. As threads virtuais, que veremos adiante, são sempre threads daemon.

Se a thread principal quiser esperar o término das threads que criou, ela usa o método [join]. O programa [Threads04.kt] também mostra como fazer uma thread executar uma função com parâmetros:

// espera pelo fim de uma thread com join - threads criadas com uma lambda
package threads04

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.concurrent.thread

fun main() {
    // a thread principal é nomeada
    Thread.currentThread().name = "Main"

    // criação e início de 5 threads
    val tasks = (0..<5).map { i ->
        // a thread executa a lambda, que chama display com parâmetros tipados
        thread(name = "$i") { display(i, 1000L + 100 * i) }
    }

    // esperamos o fim de todas as threads
    for (task in tasks) {
        // a thread principal fica bloqueada até o fim da thread [task]
        task.join()
    }
    // fim da thread principal
    println("End of thread ${Thread.currentThread().name} at ${time()}")
}

// a função executada pelas threads
fun display(number: Int, duration: Long) {
    val name = Thread.currentThread().name
    println("Start of execution of task $number in thread $name : ${time()}")
    // dormir por [duration] milissegundos
    sleep(duration)
    println("End of execution of task $number in thread $name : ${time()}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • Linhas 13–15: a função [map] converte o intervalo [0..<5] em uma lista de 5 threads, que são criadas e lançadas pela função [thread]. [tasks] é do tipo [List<Thread>];
  • linha 15: a thread executa a lambda [{ display(i, 1000L + 100 * i) }]. Essa sintaxe permite chamar uma função com parâmetros tipados (neste caso, um [Int] e um [Long]), ao passo que [run] não tem nenhum;
  • a lambda usa diretamente o parâmetro [i] da lambda de [map]. Em Java, seria preciso usar uma cópia da variável de laço ([int number = i;]), porque uma lambda Java só pode usar variáveis efetivamente finais, e a variável de laço [i] de um [for (int i = 0; …; i++)] é modificada. Em Kotlin, esse problema não surge aqui: [i] é um parâmetro e, portanto, imutável, e o mesmo vale para a variável de laço [for (i in 0..<5)], que é uma nova variável [val] a cada iteração. Kotlin também permite que uma lambda capture uma variável [var] e a modifique (Capítulo 7); no entanto, uma variável [var] compartilhada entre várias threads levanta problemas de acesso concorrente que examinaremos adiante. A armadilha que evitamos é clássica: uma thread que inicia tarde não deve ler o valor de [i] de uma iteração posterior;
  • linhas 19–21: a thread principal espera cada uma das threads. Ela fica bloqueada primeiro esperando a thread 0, depois a thread 1, e assim por diante. Ao sair do laço, as 5 threads que ela lançou terminaram;
  • linha 32: a tarefa nº i dorme por 1.000 + 100 × i milissegundos, de modo que as threads terminem em uma ordem conhecida.

Resultados:

> gradlew -q run -Pmain=threads04.Threads04Kt
Start of execution of task 2 in thread 2 : 12:15:16.127
Start of execution of task 4 in thread 4 : 12:15:16.119
Start of execution of task 0 in thread 0 : 12:15:16.130
Start of execution of task 3 in thread 3 : 12:15:16.120
Start of execution of task 1 in thread 1 : 12:15:16.118
End of execution of task 0 in thread 0 : 12:15:17.130
End of execution of task 1 in thread 1 : 12:15:17.232
End of execution of task 2 in thread 2 : 12:15:17.329
End of execution of task 3 in thread 3 : 12:15:17.430
End of execution of task 4 in thread 4 : 12:15:17.535
End of thread Main at 12:15:17.535

As mensagens de início aparecem em qualquer ordem, mas as mensagens de fim aparecem em ordem numérica, já que as durações de repouso são crescentes: essa parte do resultado é reproduzível. A última linha mostra que a thread principal terminou depois das threads que lançou, no momento em que a última delas terminou.

8.3. Parar uma thread: a interrupção

Como parar uma thread antes de ela terminar seu trabalho, por exemplo, quando o usuário cancela uma operação longa? A JVM não permite matar uma thread; ela oferece um mecanismo cooperativo chamado interrupção:

  • Cada thread tem um indicador de interrupção, um booleano inicialmente definido como [false];
  • Uma thread chamada T1 que queira terminar a thread T2 chama [T2.interrupt()]. Isso ativa o indicador de interrupção de T2. Trata-se de um pedido de término: T2 não é terminada; cabe a essa thread decidir quando e como terminar a si mesma, de modo a deixar seus dados em um estado consistente;
  • se T2 estiver bloqueada em um método de espera ([sleep], [join], [wait] e a maioria dos métodos bloqueantes de [java.util.concurrent]), ela é acordada: o método lança a exceção [InterruptedException], e o indicador de interrupção é restaurado para [false];
  • se T2 realiza cálculos sem nunca esperar, ele deve verificar o próprio flag usando [Thread.currentThread().isInterrupted] em intervalos regulares.

Em Java, os métodos bloqueantes declaram a exceção verificada [InterruptedException]: o compilador exige que o programador decida o que fazer com um pedido de parada. O Kotlin não exige isso, mas a decisão continua sendo necessária, e é a mesma. Há duas respostas corretas: deixar a exceção se propagar para o chamador ou interceptá-la e encerrar a tarefa de forma limpa. Quando nenhuma das duas opções é possível, como na função [sleep] do programa [Threads02.kt], o flag é restaurado por meio de [Thread.currentThread().interrupt()] para que o código chamador ainda possa ver o pedido. A única resposta incorreta é ignorar a exceção. O programa [Threads05.kt] demonstra os três casos:

// parada de uma thread: interrupção
package threads05

import java.time.Duration
import java.time.LocalTime
import java.time.format.DateTimeFormatter

fun main() {
    // 1 - uma thread que dorme na maior parte do tempo
    val sleeper = Thread.ofPlatform().name("sleeper").start {
        var round = 0
        try {
            while (true) {
                round++
                println("${time()} : sleeper, round $round")
                // sleep lança InterruptedException se a thread for interrompida enquanto dorme
                Thread.sleep(400)
            }
        } catch (_: InterruptedException) {
            // a interrupção é um pedido de parada: a thread termina seu trabalho de forma limpa
            println("${time()} : sleeper interrupted while sleeping, it stops")
        }
    }
    // 2 - uma thread que calcula sem nunca dormir
    val calculator = Thread.ofPlatform().name("calculator").start {
        var n = 0L
        // a thread verifica regularmente seu flag de interrupção
        while (!Thread.currentThread().isInterrupted) {
            n++
        }
        println("${time()} : calculator interrupted after %,d iterations, it stops".format(n))
    }
    // 3 - uma thread que ignora interrupções (não imitar)
    val deaf = Thread.ofPlatform().name("deaf").daemon().start {
        repeat(10) {
            try {
                Thread.sleep(400)
            } catch (_: InterruptedException) {
                // a exceção é "engolida": o pedido de parada é perdido
                println("${time()} : deaf ignores the interruption and continues")
            }
        }
    }

    // as threads são deixadas trabalhando por 1 s
    Thread.sleep(1000)
    println("${time()} : Main requests the three threads to stop")
    sleeper.interrupt()
    calculator.interrupt()
    deaf.interrupt()
    // esperar o fim de cada thread, por no máximo 1 s
    for (thread in listOf(sleeper, calculator, deaf)) {
        val finished = thread.join(Duration.ofSeconds(1))
        println("${time()} : thread ${thread.name} finished: $finished")
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 10–21: a thread [sleeper] é criada e iniciada por um builder de threads de plataforma, [Thread.ofPlatform().name("sleeper")], cujo método [start] recebe a lambda a ser executada (apresentaremos esses builders com o programa [Threads06.kt]). Ela passa a maior parte do tempo em [Thread.sleep]. O laço [while (true)] não tem condição de término: é a exceção [InterruptedException], lançada por [sleep] quando a thread é interrompida, que faz o laço terminar (linha 19). A lambda é uma instrução [try] que engloba todo o trabalho da thread: ao receber a exceção, a thread exibe uma mensagem e então termina;
  • linhas 25–31: a thread [calculator] nunca espera. Ela verifica o próprio flag de interrupção a cada iteração do laço (linha 28). O método Java [isInterrupted()] é tratado pelo Kotlin como uma propriedade Boolean [isInterrupted]. O número de iterações é exibido pela função de string do Kotlin [format], que usa os formatos de [String.format]: [%,d] exibe um inteiro com o separador de milhares do idioma atual;
  • linhas 34–40: a thread [deaf] intercepta [InterruptedException] e continua como se nada tivesse acontecido. O pedido de parada se perde: este é o erro a evitar. Trata-se de uma thread daemon ([daemon()]), de modo que o programa pode terminar sem esperar por ela;
  • linha 46: a thread principal deixa as outras threads executarem por um segundo;
  • linhas 48–50: ela solicita que as três threads parem;
  • linhas 52–54: ela espera cada thread terminar por no máximo um segundo. O método [join(Duration)] (Java 19) retorna [true] se a thread terminou nesse intervalo e [false] caso contrário. [Duration.ofSeconds(1)] representa uma duração de um segundo (classe [java.time.Duration]).

Resultados:

> gradlew -q run -Pmain=threads05.Threads05Kt
12:15:17.883 : sleeper, round 1
12:15:18.367 : sleeper, round 2
12:15:18.666 : Main requests the three threads to stop
12:15:18.671 : sleeper interrupted while sleeping, it stops
12:15:18.680 : deaf ignores the interruption and continues
12:15:18.682 : calculator interrupted after 856,531,345 iterations, it stops
12:15:18.713 : thread sleeper finished: true
12:15:18.718 : thread calculator finished: true
12:15:19.719 : thread deaf finished: false

As threads [sleeper] e [calculator] terminaram alguns milissegundos após o pedido; a thread [deaf] o ignorou e ainda não tinha terminado um segundo depois ([false], última linha). O número de iterações de calculator varia bastante de uma execução para outra, dependendo da parcela de tempo de CPU que lhe foi atribuída; o restante do resultado é reproduzível, a menos de uma ordem de grandeza, nas linhas 4 a 6.

A interrupção é o mecanismo que governa toda a biblioteca Java: veremos mais adiante que o método [cancel] de uma tarefa ([Future]) e o encerramento abrupto de um pool de threads ([shutdownNow]) interrompem as threads afetadas. As corrotinas tratadas no Capítulo 9 têm seu próprio mecanismo, o de cancelamento, que também é cooperativo, além de outras maneiras de interromper um processo, como os timeouts.

8.4. Threads virtuais

As threads que criamos até agora são threads de plataforma: cada uma é um invólucro em torno de uma thread do sistema operacional, que ela ocupa durante toda a sua existência. Uma thread do sistema operacional é um recurso caro: criá-la leva tempo, sua pilha reserva memória (da ordem de um megabyte) e o sistema não consegue gerenciar com eficiência mais do que alguns milhares delas. No entanto, um servidor que dedica uma thread a cada cliente (veja o diagrama no parágrafo seguinte) passa a maior parte do tempo esperando: pela resposta de um banco de dados, pela próxima requisição do cliente… Durante essas esperas, a thread do sistema fica bloqueada e inutilizável.

O Java 21 introduziu as threads virtuais (JEP 444), que podem ser usadas diretamente no Kotlin. Uma thread virtual é um objeto [Thread] como qualquer outro, mas é gerenciada pela Máquina Virtual Java, e não pelo sistema operacional:

  • para executar, uma thread virtual é montada em uma thread de plataforma, chamada de sua “thread transportadora” (carrier thread). As threads transportadoras formam um pequeno pool, cujo tamanho padrão é o número de processadores;
  • quando uma thread virtual bloqueia ([sleep], espera por E/S de rede, por um lock, por uma fila bloqueante etc.), ela é desmontada: sua pilha é guardada na memória da máquina virtual e a thread transportadora fica imediatamente disponível para outra thread virtual. Quando a espera termina, a thread virtual é reconectada a uma thread transportadora, não necessariamente a mesma;
  • uma thread virtual ocupa algumas centenas de bytes: é possível criar milhões delas.

As corrotinas do Kotlin (Capítulo 9) baseiam-se em uma ideia semelhante, suspender um processo que espera sem bloquear uma thread do sistema, mas implementada pelo compilador Kotlin, e não pela máquina virtual. Compararemos as duas abordagens no Capítulo 9.

O programa [Threads06.kt] compara a inicialização de 10.000 threads de plataforma e de 10.000 threads virtuais, cada uma das quais dorme por um segundo:

// threads de plataforma e threads virtuais (Java 21)
package threads06

fun main() {
    val nbThreads = 10_000
    // dois construtores de threads
    measure("platform threads", Thread.ofPlatform(), nbThreads)
    measure("virtual threads", Thread.ofVirtual(), nbThreads)

    // uma thread virtual é executada em uma thread de plataforma chamada carrier thread
    val virtual = Thread.ofVirtual().name("virtual").start {
        println("Before sleep: ${Thread.currentThread()}")
        sleep(100)
        println("After sleep: ${Thread.currentThread()}")
    }
    virtual.join()
    println("isVirtual: ${virtual.isVirtual}, isDaemon: ${virtual.isDaemon}")
}

// inicia [nbThreads] threads que dormem 1 s, espera o fim delas e exibe a duração total
fun measure(kind: String, builder: Thread.Builder, nbThreads: Int) {
    val start = System.nanoTime()
    val threads = List(nbThreads) { builder.start { sleep(1000) } }
    threads.forEach { it.join() }
    val duration = (System.nanoTime() - start) / 1_000_000
    println("%,d %s slept 1 s each: total duration %,d ms".format(nbThreads, kind, duration))
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

Comentários:

  • linhas 7–8: a função [measure] é chamada duas vezes: primeiro com um builder de threads de plataforma ([Thread.ofPlatform()]) e depois com um builder de threads virtuais ([Thread.ofVirtual()]). Ambos os builders compartilham o tipo comum [Thread.Builder]; o restante do código é idêntico. Um builder é configurado por meio de chamadas encadeadas: [name("virtual")] define o nome da thread; [name("", 0)] solicitaria threads nomeadas com um prefixo seguido de um número a partir de 0; [daemon()] (somente para threads de plataforma) solicita threads daemon. Seu método [start(Runnable)] cria uma thread e a inicia imediatamente; seu método [unstarted(Runnable)] a cria sem iniciá-la;
  • linhas 21–26: a função [measure] inicia [nbThreads] threads que dormem por um segundo, espera que terminem e exibe a duração total. A função [List(n) { … }] constrói a lista das threads criadas e iniciadas por [builder.start { … }] (uma lambda convertida em [Runnable]). O método [System.nanoTime()] retorna um tempo em nanossegundos, usado unicamente para medir durações;
  • linhas 11–14: uma thread virtual chamada [virtual] exibe sua representação textual antes e depois de uma pausa;
  • linha 17: uma thread virtual é sempre uma thread daemon.

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=threads06.Threads06Kt
10,000 platform threads slept 1 s each: total duration 4,272 ms
10,000 virtual threads slept 1 s each: total duration 1,296 ms
Before sleep: VirtualThread[#20026,virtual]/runnable@ForkJoinPool-1-worker-2
After sleep: VirtualThread[#20026,virtual]/runnable@ForkJoinPool-1-worker-1
isVirtual: true, isDaemon: true
  • 10.000 threads de plataforma levaram vários segundos para fazer o que deveria ter levado um segundo: criar as threads do sistema e gerenciar suas pilhas teve um custo elevado. Com 100.000 threads, o programa provavelmente falharia por falta de memória ou de threads do sistema disponíveis;
  • 10.000 threads virtuais concluíram a mesma tarefa em pouco mais de um segundo: enquanto dormiam, elas não ocupavam nenhuma thread do sistema. Os tempos exatos variam de uma execução para outra, mas a diferença entre os dois tipos de thread é reproduzível;
  • a representação textual de uma thread virtual ([VirtualThread[#…,virtual]]) indica, após o caractere [@], a thread transportadora na qual ela está montada: uma thread do pool [ForkJoinPool-1], que retomaremos mais adiante. Nesta execução, a thread virtual adormeceu na transportadora [worker-2] e retomou a execução na transportadora [worker-1]: ela foi de fato desmontada e depois montada novamente em outra transportadora (isso depende da execução).

As threads virtuais não tornam os cálculos mais rápidos: um cálculo que mantém o processador ocupado sem nunca esperar não é executado mais rápido em uma thread virtual do que em uma thread de plataforma, e o número de cálculos simultâneos continua limitado pelo número de processadores. A vantagem delas está em poder dedicar, sem se preocupar com o custo, uma thread a cada tarefa que passa a maior parte do tempo esperando: é o caso dos servidores, do parágrafo seguinte e dos Capítulos 12 e 13. Tudo o que abordaremos sobre sincronização de threads vale igualmente para threads virtuais e threads de plataforma.

8.5. A finalidade das threads

Agora que destacamos a existência de uma thread padrão, aquela que executa a função [main], e que sabemos criar outras, vamos examinar mais de perto os benefícios das threads. Elas têm dois usos principais:

  • aproveitar todos os processadores da máquina em um cálculo demorado: o trabalho é dividido em partes atribuídas a threads diferentes. Faremos isso usando streams paralelos e o framework [Fork/Join] no final deste capítulo;
  • executar várias tarefas simultaneamente, sobretudo quando algumas delas consistem principalmente em esperar (por uma resposta da rede, uma leitura de disco ou uma entrada do usuário). É o caso das aplicações Internet cliente/servidor, que abordaremos no Capítulo 12.

Em uma aplicação Internet cliente/servidor, um servidor localizado em uma máquina S1 responde a requisições de clientes localizados em máquinas remotas C1, C2, …, Cn:

Image

Usamos todos os dias aplicações Internet que seguem esse modelo: serviços web, e-mail, transferência de arquivos etc. No diagrama acima, o servidor S1 deve atender os clientes Ci simultaneamente. Tomando o exemplo de um servidor de arquivos, sabemos que uma transferência às vezes pode levar vários minutos. Está fora de questão que um único cliente monopolize o servidor por tanto tempo. Uma solução comum é o servidor criar tantas threads de execução quanto há clientes. Cada thread fica então responsável por atender um cliente específico:

Image

Com threads de plataforma, o servidor usa na prática um pool de threads, tratado mais adiante, cujo número limitado de threads restringe o número de clientes atendidos simultaneamente. Com threads virtuais, o esquema acima volta a ser a solução ideal: uma thread virtual por cliente, mesmo que haja dezenas de milhares de clientes, já que um cliente em espera não ocupa nenhuma thread do sistema. É o que os servidores web da JVM, como o Tomcat, que usaremos no Capítulo 13, passaram a suportar. No Kotlin, as corrotinas tratadas no Capítulo 9 oferecem outra solução para esse mesmo problema: uma corrotina por cliente.

8.6. Troca de informações entre threads

Nos exemplos anteriores, as threads executavam uma função sem parâmetros ou uma lambda que chamava uma função com parâmetros. Como o método [run] de [Runnable] não tem parâmetros nem valor de retorno, é a lambda que passa informações à thread iniciada: ela captura as variáveis de que precisa. Se a variável capturada se refere a um objeto, a thread iniciada também pode armazenar nele resultados que a thread iniciadora lerá. O programa [Threads07.kt] é o seguinte:

// troca de informações entre threads
package threads07

import java.time.Duration
import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.concurrent.thread

// as informações trocadas entre a thread que lança e a thread lançada
class Data(
    // definido pela thread que lança
    val start: LocalTime,
    val duration: Int,
) {
    // definido pela thread lançada
    lateinit var end: LocalTime
}

fun main() {
    // a thread principal é nomeada
    Thread.currentThread().name = "Main"

    // criação e início de 5 threads
    val data = mutableListOf<Data>()
    val tasks = mutableListOf<Thread>()
    for (i in 0..<5) {
        // o objeto trocado com a thread: a thread que lança define o início e a duração
        val d = Data(LocalTime.now(), i + 1)
        data += d
        // a thread lançada recebe o objeto por meio da lambda que o captura
        tasks += thread(name = "$i") { sleep(d) }
    }

    // esperamos as threads uma após a outra
    val format = DateTimeFormatter.ofPattern("HH:mm:ss")
    for ((task, d) in tasks.zip(data)) {
        // esperar o fim da thread
        task.join()
        // a thread preencheu a hora de fim de seu objeto
        val actualDuration = Duration.between(d.start, d.end).toMillis() / 1000.0
        println("Thread %s finished: start %s, scheduled duration %d s, end %s, actual duration %.3f s"
            .format(task.name, d.start.format(format), d.duration, d.end.format(format), actualDuration))
    }
    // fim da thread principal
    println("End of thread ${Thread.currentThread().name} at ${LocalTime.now().format(format)}")
}

// a função executada pelas threads
fun sleep(data: Data) {
    try {
        // dormir por [duration] segundos
        Thread.sleep(data.duration * 1000L)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
    // a thread lançada devolve um resultado à thread que lança
    data.end = LocalTime.now()
}

Comentários:

  • Linhas 10–16: a informação trocada com cada thread é um objeto [Data]. Há uma troca de informações em duas vias entre a thread iniciadora e a thread iniciada. [start] e [duration] são propriedades [val] declaradas no construtor primário: são definidas uma única vez, quando o objeto é construído:
    • [start]: a hora de início da execução da thread, definida pela thread iniciadora;
    • [duration]: duração, em segundos, da pausa da thread iniciada, definida pela thread iniciadora;
    • [end]: a hora de término da execução da thread, definida pela thread iniciada. Esta é uma propriedade [lateinit var] (Capítulo 4): ela não tem valor quando o objeto é construído, mas não é do tipo [LocalTime?]. Lê-la antes de ser atribuída lançaria a exceção [UninitializedPropertyAccessException]. A classe Java correspondente tinha quase trinta linhas, incluindo seus acessores;
  • linhas 28–29: um objeto [Data] é criado e adicionado à lista [data];
  • linha 31: a lambda [{ sleep(d) }] captura a variável [d]: a thread iniciada executará a função [sleep] das linhas 49–57 com o objeto [d] como parâmetro. O operador [+=] adiciona a thread retornada pela função [thread] à lista modificável [tasks];
  • linhas 36–42: a thread principal espera que cada uma das threads que iniciou termine e então recupera o objeto [Data] da thread e exibe seu conteúdo. A função [zip] combina as duas listas em uma lista de pares ([Pair<Thread, Data>]), que o laço [for] desestrutura em [(task, d)]. A duração real é calculada por [Duration.between(d.start, d.end)];
  • linha 52: a propriedade [duration] do parâmetro define a duração da pausa;
  • linha 57: a propriedade [end] do parâmetro é preenchida.

Resultados:

1
2
3
4
5
6
7
> gradlew -q run -Pmain=threads07.Threads07Kt
Thread 0 finished: start 12:15:25, scheduled duration 1 s, end 12:15:26, actual duration 1.014 s
Thread 1 finished: start 12:15:25, scheduled duration 2 s, end 12:15:27, actual duration 2.000 s
Thread 2 finished: start 12:15:25, scheduled duration 3 s, end 12:15:28, actual duration 3.001 s
Thread 3 finished: start 12:15:25, scheduled duration 4 s, end 12:15:29, actual duration 4.001 s
Thread 4 finished: start 12:15:25, scheduled duration 5 s, end 12:15:30, actual duration 5.004 s
End of thread Main at 12:15:30

Este exemplo mostra que duas threads podem trocar informações:

  • A thread chamadora pode controlar a execução da thread chamada fornecendo-lhe informações;
  • A thread iniciada pode devolver resultados à thread iniciadora.

Para que a thread iniciadora saiba quando os resultados que espera estão disponíveis, ela precisa ser notificada quando a thread iniciada terminar. Aqui, ela esperou o término da thread usando o método [join]. Isso não é apenas uma questão de momento: veremos na seção sobre a anotação [@Volatile] que uma operação de escrita feita por uma thread não é necessariamente visível para outra. O modelo de memória do Java, que se aplica a qualquer programa executado pela JVM, e portanto aos programas Kotlin, garante que tudo o que foi escrito por uma thread é visível para a thread que esperou o seu término usando [join], e que tudo o que foi escrito pela thread chamadora antes de [start] é visível para a thread chamada. Exploraremos outras maneiras de sincronizar mais adiante.

Em vez de uma lambda, poderíamos escrever uma classe que implementa [Runnable] e cujas propriedades contêm as informações trocadas. A lambda é mais concisa; é a forma mais comum de escrever hoje em dia. Para recuperar o resultado de um processamento, examinaremos também mais adiante a interface [Callable<V>], cujo método [call()] retorna um resultado, e, no Capítulo 9, a função [async] das corrotinas, que retorna um resultado diferido ([Deferred]).

8.7. Acesso concorrente a recursos compartilhados

8.7.1. Acesso concorrente não sincronizado

No parágrafo anterior, as informações eram trocadas apenas entre duas threads e em momentos muito específicos: era um exemplo clássico de passagem de parâmetros. Há outros casos em que as informações são compartilhadas por várias threads que podem querer lê-las ou atualizá-las ao mesmo tempo. Surge então o problema da integridade dessas informações. Suponha que a informação compartilhada seja uma estrutura S contendo várias informações I1, I2, …, In:

  • uma thread T1 começa a atualizar a estrutura S: ela modifica o campo I1 e é interrompida antes de concluir a atualização completa da estrutura S;
  • uma thread T2 que obtém o processador lê então a estrutura S para tomar decisões. Ela lê uma estrutura em estado instável: alguns campos estão atualizados, outros não.

Essa situação é chamada de acesso concorrente a um recurso compartilhado, neste caso a estrutura S. Ela costuma ser difícil de gerenciar. Consideremos o exemplo a seguir para ilustrar os problemas que podem surgir:

  • uma aplicação gerará n threads, em que n é passado como parâmetro;
  • o recurso compartilhado é um contador que deve ser incrementado por cada thread gerada;
  • no final da aplicação, o valor do contador é exibido. Ele deve, portanto, ser igual a n.

O programa [Threads08.kt] é o seguinte:

// acesso concorrente não sincronizado a um recurso compartilhado
package threads08

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.system.exitProcess

// o recurso compartilhado
object Counter {
    // o contador de threads, compartilhado por todas as threads; modificável apenas dentro do objeto
    var value = 0
        private set

    // a função executada por cada thread
    fun increment() {
        val name = Thread.currentThread().name
        // leitura do contador
        val v = value
        println("At ${time()}, thread $name read the counter value: $v")
        // espera: a thread perde o processador
        sleep(1000)
        // incremento do contador
        value = v + 1
        println("At ${time()}, thread $name wrote the counter value: $value")
    }
}

fun main(args: Array<String>) {
    // verificação do argumento: o número de threads a criar
    val nbMaxThreads = 100
    val nbThreads = args.singleOrNull()?.toIntOrNull() ?: -1
    if (nbThreads !in 1..nbMaxThreads) {
        System.err.println("syntax: threads08.Threads08Kt nbThreads (nbThreads between 1 and $nbMaxThreads)")
        exitProcess(1)
    }

    // criação e início das threads
    val threads = List(nbThreads) { i -> Thread(Counter::increment, "$i") }
    threads.forEach { it.start() }
    // esperar o fim das threads
    threads.forEach { it.join() }
    // exibição do contador
    println("Number of threads generated: ${Counter.value}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • Linhas 9–24: o recurso compartilhado é a propriedade [value] do objeto singleton [Counter] (declaração [object], Capítulo 4). O contador fica encapsulado nesse objeto, com a função [increment] executada por cada thread. A palavra-chave [private set] (linha 12) torna a propriedade legível de qualquer lugar, mas modificável apenas dentro do objeto: isso equivale ao campo privado e ao seu acessor [getValue] na versão Java;
  • linha 18: o contador é lido;
  • linha 21: a thread faz uma pausa de 1 segundo. Ela perde, portanto, a CPU;
  • linha 23: o contador é incrementado;
  • linhas 30–34: o número de threads é passado como argumento. A expressão [args.singleOrNull()?.toIntOrNull() ?: -1] retorna o inteiro contido no único argumento do programa, ou -1 se não houver exatamente um argumento ([singleOrNull] retorna então [null]) ou se esse argumento não for um inteiro ([toIntOrNull] retorna então [null]). A condição [nbThreads !in 1..nbMaxThreads] rejeita, portanto, tanto um argumento ausente ou inválido quanto um número fora do intervalo [1, 100]. Em Java, era necessário escrever um método que interceptasse [NumberFormatException]. Em caso de erro, o programa escreve uma mensagem na saída de erro ([System.err]) e termina com o código de saída 1 ([exitProcess(1)], do pacote [kotlin.system]);
  • linha 38: cada thread executa a função [increment] do objeto [Counter], referenciada pela referência vinculada [Counter::increment];
  • linhas 39–41: as threads são iniciadas e, em seguida, a thread principal espera que terminem.

A pausa de um segundo foi incluída unicamente para forçar a thread a ceder a CPU entre a leitura e a escrita do contador. Na prática, não há garantia de que uma thread não será interrompida entre esses dois momentos, e em uma máquina multiprocessada duas threads podem até ler o contador exatamente ao mesmo tempo. A pausa de um segundo apenas formaliza esse risco.

Com o Gradle, os argumentos do programa são passados usando a opção [--args]. Sem nenhum argumento, uma mensagem de erro é exibida (o comando [echo $?] no shell do Linux exibe o código de saída do último programa executado; no Windows, é [echo %errorlevel%]). Para garantir que seja exibido o código de saída do programa, e não o do Gradle (que também informa a falha da tarefa [run]), executamos aqui a classe compilada diretamente com o comando [java]:

1
2
3
4
> java -cp … threads08.Threads08Kt
syntax: threads08.Threads08Kt nbThreads (nbThreads between 1 and 100)
> echo $?
1

Com 5 threads:

> gradlew -q run -Pmain=threads08.Threads08Kt --args="5"
At 12:15:31.799, thread 3 read the counter value: 0
At 12:15:31.799, thread 0 read the counter value: 0
At 12:15:31.800, thread 2 read the counter value: 0
At 12:15:31.799, thread 4 read the counter value: 0
At 12:15:31.789, thread 1 read the counter value: 0
At 12:15:32.820, thread 3 wrote the counter value: 1
At 12:15:32.831, thread 0 wrote the counter value: 1
At 12:15:32.835, thread 4 wrote the counter value: 1
At 12:15:32.835, thread 2 wrote the counter value: 1
At 12:15:32.863, thread 1 wrote the counter value: 1
Number of threads generated: 1

Observando esses resultados, fica claro o que acontece:

  • Uma primeira thread lê o contador. Encontra 0. Faz uma pausa de 1 s e perde assim a CPU;
  • uma segunda thread também lê o valor do contador. Ele ainda é 0, pois a thread anterior ainda não o incrementou. Ela também faz uma pausa de 1 segundo;
  • em menos de um segundo, todas as 5 threads têm tempo de ler o valor 0;
  • ao acordar, elas incrementam o valor 0 que leram e todas escrevem o valor 1 no contador, como confirma a última linha (linha 11). Esse resultado incorreto é reproduzível: só a ordem das threads muda de uma execução para outra.

Poderia-se objetar que o exemplo é artificial. Então vamos remover a pausa e usar o operador [++], que dá a ilusão de uma única instrução. O programa [Threads09.kt] é o seguinte:

// atualizações perdidas sem sleep: counter++ não é atômico
package threads09

// o recurso compartilhado
object Counter {
    var value = 0
}

fun main(args: Array<String>) {
    // parâmetros: número de threads, número de incrementos por thread
    val nbThreads = args.getOrNull(0)?.toInt() ?: 4
    val nbIncrements = args.getOrNull(1)?.toInt() ?: 50_000_000

    // o experimento é repetido três vezes
    for (trial in 1..3) {
        Counter.value = 0
        // criação e início das threads
        val threads = List(nbThreads) {
            Thread.ofPlatform().start {
                repeat(nbIncrements) {
                    // ler, incrementar, escrever: três operações
                    Counter.value++
                }
            }
        }
        // esperar o fim das threads
        threads.forEach { it.join() }
        // resultado
        val expected = nbThreads * nbIncrements
        println("Trial %d: expected value %,d, value obtained %,d, lost updates %,d"
            .format(trial, expected, Counter.value, expected - Counter.value))
    }
}

Comentários:

  • linhas 11–12: o número de threads (4 por padrão) e o número de incrementos feitos por cada thread (50 milhões por padrão) podem ser passados como argumentos. [args.getOrNull(0)] retorna o primeiro argumento, ou [null] se ele não existir: o operador Elvis [?:] fornece então o valor padrão. O separador [_] torna a constante [50_000_000] legível;
  • linha 19: as threads são criadas e iniciadas por [Thread.ofPlatform().start { … }]; elas não precisam de nomes. A função [List(nbThreads) { … }] reúne as threads criadas em uma lista;
  • linha 22: cada thread incrementa o contador compartilhado sem fazer pausas;
  • linhas 30–31: na string de formato, [%,d] exibe um inteiro usando o separador de milhares do idioma atual (neste caso, o inglês: uma vírgula).

Resultados:

1
2
3
4
> gradlew -q run -Pmain=threads09.Threads09Kt
Trial 1: expected value 200,000,000, value obtained 148,585,966, lost updates 51,414,034
Trial 2: expected value 200,000,000, value obtained 200,000,000, lost updates 0
Trial 3: expected value 200,000,000, value obtained 200,000,000, lost updates 0

Dezenas de milhões de atualizações foram perdidas durante o primeiro teste. A operação de alto nível [Counter.value++] é na verdade traduzida em várias instruções básicas do processador: ler o valor da memória, incrementá-lo em um registrador e escrever o resultado na memória. Se duas threads leem o mesmo valor antes que uma delas tenha escrito o seu, um incremento é perdido, exatamente como no exemplo anterior.

Os testes 2 e 3 merecem uma explicação: eles produziram o valor exato. A explicação mais provável é a seguinte: depois de certo tempo de execução, o compilador sob demanda (JIT) da máquina virtual otimizou o laço [repeat(nbIncrements) { … }] (uma função [inline], que o compilador Kotlin substituiu por um laço simples): ele determinou que nenhuma outra thread deveria acessar o contador durante o laço (nada no código exige isso) e colocou o contador em um registrador do processador. Cada thread então lê o contador uma vez, soma 50 milhões a ele em seu registrador e o escreve de volta uma única vez no final. Se o trabalho das threads não se sobrepõe, o que foi o caso aqui, o resultado está correto; se, ao contrário, as quatro threads leem o valor 0 antes que qualquer uma delas tenha escrito, três dos quatro resultados se perdem, isto é, 150 milhões de atualizações de uma só vez. Nesta execução, apenas o primeiro teste, executado em grande parte antes dessa otimização, perdeu atualizações; em outras execuções, os testes 2 e 3 também podem perder atualizações, às vezes 150 milhões de uma só vez. É isso que torna esses erros tão perigosos: um programa pode funcionar durante meses e falhar justamente no dia em que a máquina estiver sob carga mais pesada ou funcionando mais rápido.

De onde vem o problema? Uma thread leu um valor desatualizado porque outra thread foi interrompida, ou estava trabalhando simultaneamente em outro processador, antes de terminar sua tarefa de atualizar o contador. Isso nos leva aos conceitos de recursos críticos e seções críticas em um programa:

  • um recurso crítico é um recurso que só pode ser mantido por uma thread de cada vez. Aqui, o recurso crítico é o contador;
  • uma seção crítica de um programa é uma sequência de instruções no fluxo de execução de uma thread durante a qual ela acessa um recurso crítico. Devemos garantir que, durante essa seção crítica, a thread seja a única com acesso ao recurso.

No programa [Threads08.kt], a seção crítica é o código entre a leitura do contador e a escrita de seu novo valor:

1
2
3
4
5
6
7
        // leitura do contador
        val v = value
        println("At ${time()}, thread $name read the counter value: $v")
        // espera: a thread perde o processador
        sleep(1000)
        // incremento do contador
        value = v + 1

Para executar esse código, é preciso garantir que uma thread seja a única em execução. Ela pode ser interrompida, mas, durante essa interrupção, nenhuma outra thread deve poder executar esse mesmo código. A JVM oferece várias ferramentas para garantir a entrada de uma única thread por vez nas seções críticas de código, e o Kotlin oferece algumas funções para usá-las de forma mais conveniente. Veremos algumas delas agora.

8.7.2. A função synchronized e a anotação @Synchronized

Em Java, o bloco [synchronized] delimita uma seção crítica da seguinte forma: [synchronized (lock) { …critical section… }]. [lock] é um objeto visível para todas as threads que executam a seção crítica. Na JVM, todo objeto tem um lock interno, também conhecido como monitor. O bloco [synchronized] garante que apenas uma thread por vez detenha o monitor do objeto [lock], ou seja, que apenas uma thread por vez execute a seção crítica: uma thread que encontra um monitor mantido por outra thread fica bloqueada até que o monitor seja liberado. O monitor é liberado ao sair do bloco, seja a saída normal ou causada por uma exceção.

O Kotlin não tem a palavra-chave [synchronized]. Em vez disso, sua biblioteca padrão oferece uma função [synchronized] , cuja assinatura é [inline fun <R> synchronized(lock: Any, block: () -> R): R]. Graças à sintaxe da lambda final, a chamada [synchronized(lock) { …critical section… }] é escrita exatamente como o bloco Java. Como a função é [inline], o compilador Kotlin substitui a chamada pelo corpo da lambda, cercado pelas mesmas instruções da JVM, assim como o bloco Java ([monitorenter] / [monitorexit]): não há diferença na execução. A função retorna o valor da lambda, o que nos permite escrever [val v = synchronized(lock) { counter }].

O exemplo anterior é reescrito da seguinte forma em [Threads10.kt]:

// seção crítica protegida por um bloco synchronized
package threads10

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.system.exitProcess

// o recurso compartilhado
object Counter {
    // o contador de threads
    private var counter = 0
    // o objeto de sincronização, visível para todas as threads
    private val lock = Any()

    // o valor do contador, lido sob a proteção do lock
    val value: Int
        get() = synchronized(lock) { counter }

    // a função executada por cada thread
    fun increment() {
        val name = Thread.currentThread().name
        println("At ${time()}, thread $name is waiting for permission to enter the critical section")
        // apenas uma thread por vez executa o bloco seguinte
        synchronized(lock) {
            // leitura do contador
            val v = counter
            println("At ${time()}, thread $name read the counter value: $v")
            // espera: a thread perde o processador, mas mantém o lock
            sleep(1000)
            // incremento do contador
            counter = v + 1
            println("At ${time()}, thread $name wrote the counter value: $counter")
        }
        println("At ${time()}, thread $name left the critical section")
    }
}

fun main(args: Array<String>) {
    // verificação do argumento: o número de threads a criar
    val nbMaxThreads = 100
    val nbThreads = args.singleOrNull()?.toIntOrNull() ?: -1
    if (nbThreads !in 1..nbMaxThreads) {
        System.err.println("syntax: threads10.Threads10Kt nbThreads (nbThreads between 1 and $nbMaxThreads)")
        exitProcess(1)
    }

    // criação e início das threads
    val threads = List(nbThreads) { i -> Thread(Counter::increment, "$i") }
    threads.forEach { it.start() }
    // esperar o fim das threads, na ordem inversa de sua criação
    Thread.currentThread().name = "Main"
    for (thread in threads.asReversed()) {
        println("At ${time()}, thread Main is waiting for the end of thread ${thread.name}")
        thread.join()
        println("At ${time()}, thread Main was notified of the end of thread ${thread.name}")
    }
    // exibição do contador
    println("Number of threads generated: ${Counter.value}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • Linha 13: [lock] é o objeto que permitirá a sincronização de todas as threads. Ele serve apenas a esse propósito: é um objeto simples da classe [Any], a raiz das classes Kotlin (o equivalente de [Object]). É uma propriedade [val]: a referência nunca deve mudar, caso contrário duas threads poderiam travar dois objetos diferentes. Ele é privado: nenhum código fora do objeto [Counter] pode adquirir esse lock;
  • linha 11: o contador agora é uma propriedade privada; ele só é acessível de fora por meio da propriedade [value];
  • linhas 16–17: a propriedade [value] não tem campo: seu acessor [get] lê o contador sob a proteção do lock e retorna o valor retornado pela função [synchronized], que é o valor da lambda [{ counter }]. Aqui, isso não é estritamente necessário, já que a thread principal esperou o término das outras threads usando [join]; mas é uma boa prática: os dados protegidos por um lock devem ser lidos e escritos sob a proteção desse lock;
  • linhas 24–32: a seção crítica da função [increment] é envolvida pela chamada à função [synchronized]. A thread mantém o lock enquanto dorme por um segundo: as outras threads não podem entrar;
  • linhas 52–55: a thread principal espera as threads na ordem inversa da criação. A função [asReversed] retorna uma view da lista percorrida em ordem inversa, sem copiá-la.

Resultados com 3 threads:

> gradlew -q run -Pmain=threads10.Threads10Kt --args="3"
At 12:16:51.163, thread 2 is waiting for permission to enter the critical section
At 12:16:51.163, thread Main is waiting for the end of thread 2
At 12:16:51.165, thread 1 is waiting for permission to enter the critical section
At 12:16:51.157, thread 0 is waiting for permission to enter the critical section
At 12:16:51.170, thread 2 read the counter value: 0
At 12:16:52.181, thread 2 wrote the counter value: 1
At 12:16:52.182, thread 1 read the counter value: 1
At 12:16:52.182, thread 2 left the critical section
At 12:16:52.182, thread Main was notified of the end of thread 2
At 12:16:52.182, thread Main is waiting for the end of thread 1
At 12:16:53.182, thread 1 wrote the counter value: 2
At 12:16:53.182, thread 0 read the counter value: 2
At 12:16:53.182, thread 1 left the critical section
At 12:16:53.183, thread Main was notified of the end of thread 1
At 12:16:53.183, thread Main is waiting for the end of thread 0
At 12:16:54.183, thread 0 wrote the counter value: 3
At 12:16:54.183, thread 0 left the critical section
At 12:16:54.183, thread Main was notified of the end of thread 0
Number of threads generated: 3
  • As três threads solicitam a entrada na seção crítica quase ao mesmo tempo;
  • apenas uma entra, neste caso a thread 2 (a ordem de entrada não é garantida: não é necessariamente a primeira a chegar que entra primeiro). Ela lê o contador, dorme por um segundo, escreve o novo valor e sai da seção crítica;
  • as outras duas threads ficam bloqueadas até que a primeira saia da seção crítica e depois prosseguem uma após a outra. Cada uma lê o valor escrito pela anterior. Observe (linhas 7–8) que a Thread 1 leu o contador antes que a Thread 2 indicasse que havia saído da seção crítica: a Thread 2 de fato liberou o lock, mas só exibe sua mensagem depois do bloco [synchronized], e a Thread 1 foi mais rápida;
  • a thread principal esperava o término da Thread 2. Ao ser notificada de que a Thread 2 havia terminado, esperou o término da Thread 1 e depois o da Thread 0;
  • O número de threads está correto (última linha). Independentemente da ordem em que as threads são executadas, esse resultado é reproduzível.

Em Java, a palavra-chave [synchronized] também pode ser usada para anotar um método inteiro. O Kotlin oferece a anotação [@Synchronized] (pacote [kotlin.jvm], importado automaticamente) para essa finalidade: [@Synchronized fun m() { … }] gera um método Java [synchronized], que equivale a uma chamada [synchronized(this) { … }] que engloba todo o corpo da função. Em um [object] como [Counter], o objeto travado é o próprio objeto singleton. Vamos usá-la no programa [Threads17.kt]. Essa é a sintaxe mais curta. No entanto, ela tem um inconveniente: o objeto travado é visível de fora, e um código externo pode adquirir o mesmo lock e bloquear o nosso. Por isso, muitas vezes é preferível travar um objeto privado, como no exemplo. Pela mesma razão, nunca se deve travar uma string (literais de string idênticos são um único objeto compartilhado em todo o programa). O Kotlin vai um passo além do Java no que diz respeito aos números: travar um *[Int]*, que seria convertido em um objeto *[Integer]* compartilhado, é um erro de compilação (***[error: synchronizing on 'Int' is forbidden.]***), enquanto o Java emite apenas um aviso para objetos de classes “baseadas em valor” (value-based).

Uma thread que já detém um monitor pode entrar novamente em um bloco [synchronized] sobre o mesmo objeto sem se bloquear: diz-se que o lock é reentrante. Uma função [@Synchronized] pode, assim, chamar outra função [@Synchronized] sobre o mesmo objeto.

8.7.3. A classe ReentrantLock

O lock [synchronized] é simples, mas rígido: uma thread que espera por um monitor espera indefinidamente, sem poder desistir após certo tempo e sem poder ser interrompida. A classe [java.util.concurrent.locks.ReentrantLock] (Java 5) é um lock explícito, também reentrante, que oferece essas capacidades. Ela implementa a interface [Lock]. Usaremos os seguintes construtores e métodos:

Membro
Função
[ReentrantLock()], [ReentrantLock(fair: Boolean)]
cria um lock. Um lock justo ([true]) é concedido às threads na ordem em que o solicitaram; um lock não justo (o padrão) é mais rápido, mas uma thread pode furar a fila
[lock()]
A thread T1, que está executando [V.lock()], solicita o lock V. Se V não é mantido por nenhuma thread, ele é concedido a T1. Se uma thread T2 realiza então a mesma operação, ela fica bloqueada: um lock só pode pertencer a uma thread. T2 será desbloqueada quando T1 liberar V. Assim, várias threads podem ficar bloqueadas esperando por V
[tryLock(): Boolean], [tryLock(time: Long, unit: TimeUnit): Boolean]
solicita o lock imediatamente, ou esperando no máximo [time]. O método retorna [false] se não foi possível adquirir o lock
[lockInterruptibly()]
como [lock], mas a espera pode ser interrompida ([InterruptedException])
[unlock()]
A thread que detém V o libera. Uma das threads que esperam por V o adquire então
[isHeldByCurrentThread]
indica se a thread atual detém o lock
[newCondition(): Condition]
Cria uma condição associada ao lock (veja abaixo)
[withLock { … }]
(biblioteca Kotlin, pacote [kotlin.concurrent]) função de extensão da interface [Lock]: executa a lambda enquanto mantém o lock e o libera no final, ocorrendo ou não uma exceção

Em Java, a sincronização de uma seção crítica segue sempre o mesmo padrão: [V.lock(); try { …critical section… } finally { V.unlock(); }]. É importante não esquecer de liberar o lock; caso contrário, as threads que o esperam permanecerão bloqueadas indefinidamente. Por isso o lock é liberado em um bloco [finally], que é executado ocorrendo ou não uma exceção. O bloco *[synchronized] faz isso automaticamente; com *[ReentrantLock]*, cabe ao programador fazê-lo. O Kotlin pode escrever exatamente a mesma coisa, mas sua biblioteca padrão oferece uma solução melhor: a função de extensão [withLock]*, que aplica esse padrão de uma vez por todas. Sua definição é, em essência, a seguinte:

1
2
3
4
5
6
7
8
public inline fun <T> Lock.withLock(action: () -> T): T {
    lock()
    try {
        return action()
    } finally {
        unlock()
    }
}

Esta é uma função [inline]: a chamada a [lock.withLock { … }] é substituída em tempo de compilação pelo esquema [lock] / [try] / [finally] / [unlock], sem custo adicional, e torna-se impossível omitir [unlock]. É o mesmo processo da função [use], que substitui a instrução [try] com recurso do Java (Capítulo 3). O programa [Threads11.kt] retoma o exemplo anterior com um [ReentrantLock]:

// seção crítica protegida por um ReentrantLock
package threads11

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock
import kotlin.system.exitProcess

// o recurso compartilhado
object Counter {
    // o contador de threads
    private var counter = 0
    // o objeto de sincronização: um lock justo (true)
    private val lock = ReentrantLock(true)

    // o valor do contador, lido sob a proteção do lock
    val value: Int
        get() = lock.withLock { counter }

    // a função executada por cada thread
    fun increment() {
        val name = Thread.currentThread().name
        println("At ${time()}, thread $name is waiting for permission to enter the critical section")
        // o lock é solicitado; withLock o libera ao sair do bloco, com exceção ou não
        lock.withLock {
            // leitura do contador
            val v = counter
            println("At ${time()}, thread $name read the counter value: $v")
            // espera
            sleep(1000)
            // incremento do contador
            counter = v + 1
            println("At ${time()}, thread $name wrote the counter value: $counter")
            println("At ${time()}, thread $name leaves the critical section")
        }
    }
}

fun main(args: Array<String>) {
    // verificação do argumento: o número de threads a criar
    val nbMaxThreads = 100
    val nbThreads = args.singleOrNull()?.toIntOrNull() ?: -1
    if (nbThreads !in 1..nbMaxThreads) {
        System.err.println("syntax: threads11.Threads11Kt nbThreads (nbThreads between 1 and $nbMaxThreads)")
        exitProcess(1)
    }

    // criação e início das threads
    val threads = List(nbThreads) { i -> Thread(Counter::increment, "$i") }
    threads.forEach { it.start() }
    // esperar o fim das threads
    threads.forEach { it.join() }
    // exibição do contador
    println("Number of threads generated: ${Counter.value}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

O programa principal é o de [Threads08.kt]. Comentários:

  • linha 15: o objeto de sincronização das threads agora é um lock justo, [ReentrantLock];
  • linha 7: a função de extensão [withLock] precisa ser importada;
  • linha 26: início da seção crítica. A thread fica bloqueada até que o lock seja liberado;
  • linhas 26–35: como um lock deve sempre ser liberado, ocorrendo ou não uma exceção, a seção crítica é a lambda passada a *[withLock]*, que libera o lock ao sair da lambda. A mensagem “sai da seção crítica” é a última exibida dentro da seção crítica;
  • linhas 18–19: o mesmo processo protege a leitura do contador. [withLock] retorna o valor de sua lambda: o valor retornado pelo acessor é lido enquanto o lock é mantido. A versão Java precisava escrever sete linhas de código [try] / [finally] para essa simples operação de leitura.

Resultados:

> gradlew -q run -Pmain=threads11.Threads11Kt --args="3"
At 12:16:54.619, thread 2 is waiting for permission to enter the critical section
At 12:16:54.607, thread 0 is waiting for permission to enter the critical section
At 12:16:54.608, thread 1 is waiting for permission to enter the critical section
At 12:16:54.647, thread 2 read the counter value: 0
At 12:16:55.671, thread 2 wrote the counter value: 1
At 12:16:55.672, thread 2 leaves the critical section
At 12:16:55.699, thread 0 read the counter value: 1
At 12:16:56.700, thread 0 wrote the counter value: 2
At 12:16:56.700, thread 0 leaves the critical section
At 12:16:56.700, thread 1 read the counter value: 2
At 12:16:57.701, thread 1 wrote the counter value: 3
At 12:16:57.701, thread 1 leaves the critical section
Number of threads generated: 3

Os resultados são semelhantes aos anteriores: as threads passam pela seção crítica uma a uma, e a contagem final está correta. Como o lock é justo, as threads o adquiriram na ordem em que o solicitaram: a ordem de suas chamadas a [lock], que as horas das mensagens “esperando permissão”, calculadas um pouco antes, apenas aproximam (aqui, a thread 2 mostrou a hora mais tardia, mas chamou [lock] primeiro).

Quando usar [ReentrantLock] em vez de [synchronized]? Quando você precisa de um de seus recursos adicionais: timeout ([tryLock], que usaremos para evitar o deadlock), espera interruptível, justiça (fairness) ou várias condições. Fora isso, a função [synchronized] funciona muito bem; com [withLock], o Kotlin torna o uso de ambas as ferramentas igualmente simples e seguro. Desde o Java 24, [synchronized] não causa mais problemas com threads virtuais: antes, uma thread virtual bloqueada em um bloco [synchronized] não conseguia liberar sua thread transportadora, o que fazia de [ReentrantLock] a escolha preferida.

8.7.4. Sincronização de processos: o lock de arquivo

Os locks anteriores sincronizam threads dentro da mesma máquina virtual, isto é, dentro do mesmo processo. Às vezes, processos diferentes precisam compartilhar um recurso, como um arquivo, ou você pode querer impedir que duas instâncias da mesma aplicação sejam iniciadas. A JVM não oferece um objeto de sincronização nomeado compartilhado entre processos; para essa finalidade, usa-se um lock de arquivo gerenciado pelo sistema operacional: a classe [java.nio.channels.FileLock]. Um lock é obtido sobre um arquivo aberto na forma de um canal [FileChannel]:

  • [lock(): FileLock]: espera que o lock esteja disponível e o adquire;
  • [tryLock(): FileLock?]: tenta adquirir o lock sem esperar e retorna [null] se ele estiver mantido por outro processo. O Kotlin trata o valor de retorno desse método Java como um tipo de plataforma ([FileLock!]); cabe ao programador tratá-lo como potencialmente [null];
  • [release()]: libera o lock. O lock também é liberado quando o canal é fechado ou quando o processo termina, mesmo que de forma abrupta: um lock não pode ficar “órfão”. A classe [FileLock] implementa a interface [AutoCloseable]: seu método [close] chama [release], e a função Kotlin [use] pode, portanto, liberar o lock.

O programa [Threads12.kt] é iniciado duas vezes, em dois processos diferentes, que compartilham uma seção crítica:

// um lock de arquivo sincroniza processos diferentes
package threads12

import java.nio.channels.FileChannel
import java.nio.file.Path
import java.nio.file.StandardOpenOption.CREATE
import java.nio.file.StandardOpenOption.WRITE
import java.time.LocalTime
import java.time.format.DateTimeFormatter

fun main(args: Array<String>) {
    // o arquivo bloqueado é conhecido por todos os processos que o usam
    val file = Path.of(System.getProperty("java.io.tmpdir"), "kotlin-course-threads-12.lock")
    // o nome do processo é passado como argumento
    val process = args.firstOrNull() ?: "P"

    // o arquivo é aberto (é criado se ainda não existir)
    FileChannel.open(file, CREATE, WRITE).use { channel ->
        println("${time()} : process $process requests the lock")
        // tentativa sem espera: null se outro processo detiver o lock
        val lock = channel.tryLock() ?: run {
            println("${time()} : the lock is held by another process, $process waits")
            // espera sem limite de tempo
            channel.lock()
        }
        // use libera o lock ao fim do bloco (close chama release)
        lock.use {
            // seção crítica entre processos
            println("${time()} : process $process obtained the lock, it works for 3 s")
            Thread.sleep(3000)
            println("${time()} : process $process releases the lock")
        }
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • Linha 13: o arquivo usado como lock. Todos os processos que travam esse arquivo se sincronizam entre si. Ele é colocado na pasta de arquivos temporários do sistema, indicada pela propriedade de sistema [java.io.tmpdir] ([/tmp] no Linux). Seu conteúdo é irrelevante: ele pode permanecer vazio;
  • Linha 18: o arquivo é aberto para escrita (um lock exclusivo exige isso) e criado se ainda não existir ([CREATE]). As constantes da enumeração [StandardOpenOption] foram importadas uma a uma (linhas 6–7). A função [use] fechará o canal no final;
  • linhas 21–24: o processo tenta adquirir o lock sem esperar. Se falhar ([tryLock] retorna [null]), o operador Elvis [?:] executa o bloco [run], que sinaliza isso e depois espera indefinidamente pelo lock: o valor do bloco, o lock retornado por [lock], torna-se o valor da variável [lock]. Essa variável é, portanto, de um tipo não nulo;
  • linhas 27–31: a seção crítica, que dura 3 segundos, seguida da liberação do lock pela função [use].

Um lock de arquivo pertence ao processo inteiro, e não a uma única thread: ele não serve para sincronizar threads dentro do mesmo processo (dois pedidos de lock sobre o mesmo arquivo dentro do mesmo processo disparam a exceção [OverlappingFileLockException]). Iniciamos o processo A, esperamos 1,5 segundo e então iniciamos o processo B em um segundo terminal. Resultados do processo A:

1
2
3
4
> gradlew -q run -Pmain=threads12.Threads12Kt --args="A"
12:16:58.028 : process A requests the lock
12:16:58.040 : process A obtained the lock, it works for 3 s
12:17:01.041 : process A releases the lock

Resultados do processo B:

1
2
3
4
5
> gradlew -q run -Pmain=threads12.Threads12Kt --args="B"
12:16:59.552 : process B requests the lock
12:16:59.604 : the lock is held by another process, B waits
12:17:01.060 : process B obtained the lock, it works for 3 s
12:17:04.064 : process B releases the lock

O processo B detectou o lock mantido pelo processo A e esperou. Ele adquiriu o lock alguns milissegundos depois que A o liberou. Um uso comum desse mecanismo é impedir o início de duas instâncias da mesma aplicação: a segunda instância, incapaz de adquirir o lock com [tryLock], termina imediatamente.

8.7.5. Uma barreira: a classe Semaphore

Um semáforo é um contador de permissões (ou vagas). A classe [java.util.concurrent.Semaphore] oferece os seguintes métodos:

Membro
Função
[Semaphore(permits: Int)], [Semaphore(permits: Int, fair: Boolean)]
cria um semáforo com [permits] permissões; o segundo parâmetro tem o mesmo significado que em [ReentrantLock]
[acquire()]
adquire uma permissão. Se não restam permissões, a thread fica bloqueada até que uma permissão seja liberada. A espera pode ser interrompida ([InterruptedException])
[acquireUninterruptibly()]
igual ao anterior, mas a espera não pode ser interrompida
[tryAcquire(): Boolean], [tryAcquire(timeout: Long, unit: TimeUnit): Boolean]
obtém uma permissão sem esperar, ou esperando no máximo [timeout]; retorna [false] em caso de falha
[release()]
devolve (adiciona) uma permissão; uma das threads em espera pode então obtê-la
[availablePermits()]
o número de permissões disponíveis

Diferentemente de um lock, uma permissão não pertence a nenhuma thread específica: qualquer thread pode chamar [release], mesmo que nunca tenha adquirido uma permissão. Um semáforo criado com zero permissões é, portanto, uma barreira fechada, na qual as threads que chamam [acquire] ficam bloqueadas. Outra thread a abrirá quando chegar a hora, chamando [release]. Esse momento depende inteiramente do problema a resolver. A thread que adquiriu a única permissão atravessou a barreira, que se fechou atrás dela; ao devolver a permissão, ela abre a barreira para outra thread. Se, no exemplo anterior, substituirmos o lock por uma barreira desse tipo, o código fica assim ([Threads13.kt]):

// seção crítica protegida por uma barreira: um semáforo com uma única permissão
package threads13

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.Semaphore
import kotlin.system.exitProcess

// o recurso compartilhado
object Counter {
    // o contador de threads
    var value = 0
        private set
    // a barreira: um semáforo criado sem nenhuma permissão, portanto fechado
    val sync = Semaphore(0)

    // a função executada por cada thread
    fun increment() {
        val name = Thread.currentThread().name
        println("At ${time()}, thread $name is waiting for permission to enter the critical section")
        // travessia da barreira: a thread pega a única permissão, a barreira se fecha atrás dela
        sync.acquireUninterruptibly()
        try {
            // leitura do contador
            val v = value
            println("At ${time()}, thread $name read the counter value: $v")
            // espera
            sleep(1000)
            // incremento do contador
            value = v + 1
            println("At ${time()}, thread $name wrote the counter value: $value")
        } finally {
            // a permissão é devolvida: a barreira se abre para outra thread
            println("At ${time()}, thread $name leaves the critical section")
            sync.release()
        }
    }
}

fun main(args: Array<String>) {
    // verificação do argumento: o número de threads a criar
    val nbMaxThreads = 100
    val nbThreads = args.singleOrNull()?.toIntOrNull() ?: -1
    if (nbThreads !in 1..nbMaxThreads) {
        System.err.println("syntax: threads13.Threads13Kt nbThreads (nbThreads between 1 and $nbMaxThreads)")
        exitProcess(1)
    }

    // criação e início das threads
    val threads = List(nbThreads) { i -> Thread(Counter::increment, "$i") }
    threads.forEach { it.start() }
    // as threads têm permissão de alcançar a barreira fechada
    Thread.sleep(500)
    // a barreira da seção crítica é aberta
    Thread.currentThread().name = "Main"
    println("At ${time()}, thread Main opens the barrier of the critical section")
    Counter.sync.release()
    // esperar o fim das threads
    threads.forEach { it.join() }
    // exibição do contador
    println("Number of threads generated: ${Counter.value}")
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 15: a barreira é criada no estado fechado. Ela será aberta pela thread principal na linha 57;
  • linha 53: a thread principal espera meio segundo para dar tempo às threads de chegarem à barreira;
  • linha 22: a thread responsável por incrementar o contador solicita permissão para entrar na seção crítica. As várias threads se acumulam diante da barreira fechada. Quando a thread principal a abre, uma das threads em espera passa, e a barreira se fecha novamente. O método [acquireUninterruptibly] torna a thread insensível a interrupções durante essa espera;
  • Linhas 23–35: a seção crítica é envolvida por um *[try], cuja cláusula *[finally]* libera o lock. A biblioteca padrão do Kotlin não tem um equivalente a *[withLock] para os semáforos Java: escrevemos o padrão [try] / [finally] como em Java (a biblioteca de corrotinas, no entanto, tem seu próprio semáforo, com uma função [withPermit], que veremos no Capítulo 9);
  • Linha 35: ao terminar seu trabalho, a thread reabre a barreira, permitindo que outra thread entre.

Resultados:

> gradlew -q run -Pmain=threads13.Threads13Kt --args="3"
At 12:17:04.442, thread 1 is waiting for permission to enter the critical section
At 12:17:04.463, thread 0 is waiting for permission to enter the critical section
At 12:17:04.503, thread 2 is waiting for permission to enter the critical section
At 12:17:04.807, thread Main opens the barrier of the critical section
At 12:17:04.812, thread 0 read the counter value: 0
At 12:17:05.818, thread 0 wrote the counter value: 1
At 12:17:05.819, thread 0 leaves the critical section
At 12:17:05.820, thread 1 read the counter value: 1
At 12:17:06.821, thread 1 wrote the counter value: 2
At 12:17:06.821, thread 1 leaves the critical section
At 12:17:06.821, thread 2 read the counter value: 2
At 12:17:07.822, thread 2 wrote the counter value: 3
At 12:17:07.822, thread 2 leaves the critical section
Number of threads generated: 3

Os resultados são semelhantes aos anteriores. Vemos que as três threads esperam na barreira até que a thread principal a abra (linha 4).

8.7.6. As classes CountDownLatch e Semaphore

Dois usos adicionais das ferramentas de sincronização complementam os exemplos anteriores.

Um objeto [java.util.concurrent.CountDownLatch] é um contador: ele é criado com um valor inicial N; cada chamada ao seu método [countDown] o decrementa; seu método [await] bloqueia a thread chamadora até que o contador chegue a 0. Ao chegar a 0, ele permanece lá: a barreira fica permanentemente aberta e deixa passar todas as threads. Com N = 1, serve como “sinal de largada” de uma corrida; com N = o número de tarefas, é uma maneira de esperar a conclusão de N tarefas, cada uma das quais chama [countDown] ao terminar. O programa [Threads14.kt] é o seguinte:

// CountDownLatch: um sinal de largada que libera todas as threads em espera
package threads14

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread

fun main() {
    // o sinal de largada: uma contagem regressiva que começa em 1
    val start = CountDownLatch(1)

    // criação e início de 4 threads
    val threads = List(4) { i ->
        thread(name = "$i") {
            val name = Thread.currentThread().name
            println("${time()} : runner $name is waiting for the start signal")
            try {
                // esperar a contagem regressiva chegar a 0
                start.await()
                println("${time()} : runner $name has started")
            } catch (_: InterruptedException) {
                println("${time()} : runner $name gave up")
            }
        }
    }

    // a thread principal espera 1 s e depois dá o sinal de largada
    Thread.sleep(1000)
    println("${time()} : start signal")
    // a contagem regressiva chega a 0: todas as threads em espera são liberadas
    start.countDown()
    // esperar o fim das threads
    threads.forEach { it.join() }
    println("Value of the countdown: ${start.count}")
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 11: a contagem regressiva começa em 1: o portão está fechado;
  • linhas 14–15: as 4 threads (os corredores) são criadas e iniciadas pela função [thread] e adicionadas a uma lista pela função [List(4) { i -> … }];
  • linha 20: cada thread espera que a contagem regressiva chegue a 0. O método [await] pode lançar [InterruptedException]; se a thread for interrompida durante a espera, ela abandona a corrida (linha 23);
  • linha 32: a thread principal decrementa o contador regressivo após um segundo; ele chega a 0;
  • linha 35: a propriedade [count] (o método Java [getCount()]) retorna o valor atual do contador regressivo.

Resultados:

> gradlew -q run -Pmain=threads14.Threads14Kt
12:17:08.372 : runner 1 is waiting for the start signal
12:17:08.363 : runner 3 is waiting for the start signal
12:17:08.384 : runner 2 is waiting for the start signal
12:17:08.363 : runner 0 is waiting for the start signal
12:17:09.275 : start signal
12:17:09.300 : runner 1 has started
12:17:09.301 : runner 3 has started
12:17:09.301 : runner 2 has started
12:17:09.302 : runner 0 has started
Value of the countdown: 0

Os quatro corredores largaram juntos, com poucos milissegundos de diferença, após o sinal de largada. Um [CountDownLatch] só é usado uma vez; a classe [CyclicBarrier] oferece um ponto de encontro reutilizável (as N threads esperam umas pelas outras e depois partem juntas), e a classe [Phaser] generaliza essas duas ferramentas.

Voltemos ao semáforo em seu uso mais comum: um semáforo de N permissões permite que no máximo N threads entrem em uma seção de código por vez. Isso é útil para limitar o acesso a um recurso disponível em quantidade limitada (conexões de banco de dados, requisições simultâneas a um servidor etc.). O programa [Threads15.kt] é o seguinte:

// Semaphore: no máximo N threads por vez em uma seção de código
package threads15

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.Semaphore
import kotlin.concurrent.thread

fun main() {
    // um semáforo com 2 permissões (2 vagas)
    val semaphore = Semaphore(2)

    // criação e início de 5 threads
    val threads = List(5) { i ->
        thread(name = "$i") {
            val name = Thread.currentThread().name
            println("${time()} : thread $name is waiting for a place")
            // uma vaga é solicitada: bloqueante se não restar nenhuma
            semaphore.acquireUninterruptibly()
            try {
                println("${time()} : thread $name obtained a place" +
                        " (free places: ${semaphore.availablePermits()})")
                // trabalho
                sleep(1000)
            } finally {
                // a vaga é devolvida
                println("${time()} : thread $name releases its place")
                semaphore.release()
            }
        }
    }
    // esperar o fim das threads
    threads.forEach { it.join() }
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 11: o semáforo tem 2 permissões: 2 vagas;
  • linha 19: uma thread solicita uma vaga. Se houver uma disponível, ela a toma e continua; caso contrário, fica bloqueada até que uma vaga fique disponível;
  • linha 22: o número de vagas ainda disponíveis;
  • linha 28: a thread devolve sua vaga, em uma cláusula [finally].

Resultados:

> gradlew -q run -Pmain=threads15.Threads15Kt
12:17:09.754 : thread 4 is waiting for a place
12:17:09.755 : thread 3 is waiting for a place
12:17:09.791 : thread 3 obtained a place (free places: 0)
12:17:09.770 : thread 2 is waiting for a place
12:17:09.784 : thread 0 is waiting for a place
12:17:09.764 : thread 1 is waiting for a place
12:17:09.786 : thread 4 obtained a place (free places: 1)
12:17:10.798 : thread 3 releases its place
12:17:10.803 : thread 2 obtained a place (free places: 0)
12:17:10.805 : thread 4 releases its place
12:17:10.805 : thread 0 obtained a place (free places: 0)
12:17:11.831 : thread 0 releases its place
12:17:11.831 : thread 1 obtained a place (free places: 0)
12:17:11.831 : thread 2 releases its place
12:17:12.831 : thread 1 releases its place

As cinco threads solicitam uma vaga; duas a obtêm imediatamente (neste caso, as threads 3 e 4), enquanto as outras três esperam. Cada vez que uma thread libera sua vaga, uma thread em espera a obtém. Nunca há mais de duas threads na seção de código. Observe que a thread 3 exibe “free places: 0” antes de a thread 4 exibir “free places: 1”: a thread 4 adquiriu sua vaga e leu primeiro o número de vagas livres, mas a thread 3 foi mais rápida em exibir sua mensagem. Um semáforo de uma única permissão funciona como um lock, como no programa [Threads13.kt]. Com threads virtuais, o semáforo é a ferramenta natural para limitar a concorrência: em vez de limitar o número de threads, criamos uma thread virtual por tarefa e usamos um semáforo para limitar o número de tarefas que usam simultaneamente o recurso escasso. Faremos o mesmo no Capítulo 9 com as corrotinas.

8.7.7. Visibilidade das escritas: a anotação @Volatile

Os locks não servem apenas para tornar indivisível um grupo de operações. Eles resolvem um segundo problema, mais insidioso: a visibilidade das escritas. Para ganhar velocidade, o processador armazena valores em seus registradores e caches, e o compilador reordena ou elimina leituras e escritas em tempo de execução, como vimos com o programa [Threads09.kt]. O resultado é que um valor escrito por uma thread pode não ser visto por outra thread até mais tarde, ou talvez nunca.

O Modelo de Memória do Java , que rege todos os programas executados pela JVM, incluindo os programas Kotlin, define com precisão quando uma escrita tem visibilidade garantida: quando existe uma relação “happens-before” entre a escrita e a leitura. As principais são as seguintes:

  • Tudo o que uma thread fez antes de liberar um lock (fim de um bloco [synchronized], [unlock]) é visível para a thread que adquire esse lock em seguida;
  • o que a thread chamadora fez antes de [start] é visível para a thread chamada; o que uma thread fez é visível para a thread que esperou seu término por meio de [join];
  • uma escrita em um campo [volatile] é visível para qualquer leitura posterior desse campo;
  • as ferramentas de [java.util.concurrent] oferecem garantias semelhantes: o que uma thread fez antes de [release()], [countDown()], ou da inserção de um elemento em uma coleção concorrente, é visível para a thread que em seguida executa [acquire()], [await()], ou recupera o elemento.

Quando nenhuma dessas relações existe, diz-se que o programa contém uma “corrida de dados” (data race), e não há garantias. Em Java, um campo é declarado [volatile] por meio de uma palavra-chave; o Kotlin não tem essa palavra-chave, mas tem uma anotação, [@Volatile], que se aplica a uma propriedade [var]: o campo que armazena a propriedade passa então a ser um campo Java [volatile]. O programa [Threads16.kt] demonstra sua utilidade em um cenário comum: um flag que instrui uma thread a parar.

// visibilidade das escritas entre threads: a anotação @Volatile
package threads16

import java.time.Duration
import java.time.LocalTime
import java.time.format.DateTimeFormatter

// os flags de parada, compartilhados pelas threads
object Flags {
    // uma propriedade comum: uma thread pode nunca ver o novo valor
    var stop = false
    // uma propriedade volatile: toda escrita é visível para as leituras que a seguem
    @Volatile
    var volatileStop = false
}

fun main() {
    // 1 - o flag de parada é uma propriedade comum
    val t1 = Thread.ofPlatform().name("T1").daemon().start {
        var rounds = 0L
        while (!Flags.stop) {
            rounds++
        }
        println("${time()} : T1 saw the stop request after %,d rounds".format(rounds))
    }
    // 2 - o flag de parada é uma propriedade volatile
    val t2 = Thread.ofPlatform().name("T2").daemon().start {
        var rounds = 0L
        while (!Flags.volatileStop) {
            rounds++
        }
        println("${time()} : T2 saw the stop request after %,d rounds".format(rounds))
    }

    // as threads são deixadas em execução por um segundo
    Thread.sleep(1000)
    println("${time()} : Main requests T1 and T2 to stop")
    Flags.stop = true
    Flags.volatileStop = true
    // esperar o fim das duas threads, por no máximo 2 s cada
    for (thread in listOf(t2, t1)) {
        val finished = thread.join(Duration.ofSeconds(2))
        println("${time()} : ${thread.name} finished: $finished")
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 9–14: os dois flags, que são propriedades do objeto singleton [Flags]. A anotação [@Volatile] (linha 13), importada automaticamente, especifica que toda leitura da propriedade [volatileStop] deve ser feita na memória e que toda escrita nela deve ser realizada imediatamente. A propriedade [stop] é uma propriedade comum;
  • linhas 19–24: a thread T1 executa enquanto a propriedade comum [Flags.stop] for igual a [false];
  • linhas 27–32: a thread T2 faz o mesmo com a propriedade volátil [Flags.volatileStop];
  • linhas 38–39: após um segundo, a thread principal passa os dois flags para [true];
  • linhas 41–43: ela espera cada uma das duas threads por até 2 segundos. Ambas as threads são daemons, de modo que o programa pode terminar mesmo que uma delas ainda esteja em execução.

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=threads16.Threads16Kt
12:18:56.183 : Main requests T1 and T2 to stop
12:18:56.214 : T2 saw the stop request after 468,368,999 rounds
12:18:56.340 : T2 finished: true
12:18:58.360 : T1 finished: false

A thread T2 recebeu o pedido de parada imediatamente. A thread T1, por outro lado, nunca o recebeu: ainda estava em execução dois segundos depois e só parou quando a máquina virtual foi encerrada. O compilador just-in-time, constatando que o laço [while (!Flags.stop) { rounds++ }] não modifica [stop] e que nenhuma sincronização exige que ele seja lido novamente, leu esse campo apenas uma vez, antes do laço: o laço tornou-se, assim, um laço infinito. O acesso à propriedade [stop] é feito por meio de seu acessor [getStop], mas isso não faz diferença: o compilador just-in-time substituiu a chamada ao acessor por uma leitura do campo. Esse comportamento é reproduzível com a máquina virtual HotSpot usada aqui, mas não é garantido: outra máquina virtual, ou outra versão, poderia permitir que T1 parasse. É precisamente esse o problema: sem uma relação happens-before, o comportamento do programa é indefinido.

A anotação [@Volatile] garante a visibilidade, mas não a atomicidade: [value++] em uma propriedade [@Volatile] continua sendo uma leitura seguida de uma escrita, e duas threads ainda podem perder uma atualização. [@Volatile] é, portanto, adequada para um flag escrito por uma thread e lido por outras, mas não para um contador compartilhado. Para parar uma thread, a interrupção descrita anteriormente é, na verdade, preferível a um flag: ela também acorda uma thread que está bloqueada em uma espera.

8.7.8. Classes atômicas

O pacote [java.util.concurrent.atomic] (Java 5) oferece classes que tornam atômicas operações simples sobre uma variável: a operação é executada inteiramente pela thread, sem que nenhuma outra thread possa observar ou modificar a variável no meio da operação. As ferramentas anteriores ([synchronized], [ReentrantLock], [Semaphore]) foram todas concebidas para tornar atômico um grupo de operações, ao custo de bloquear outras threads. Para operações simples, porém frequentes, as classes atômicas evitam esse bloqueio usando instruções especiais do processador. Os principais métodos da classe [AtomicInteger] são os seguintes:

Método
Função
[get(): Int], [set(v: Int)]
lê e escreve o valor (com a semântica de um campo [volatile])
[incrementAndGet(): Int], [decrementAndGet(): Int]
incrementam (decrementam) o valor em 1 e retornam o novo valor
[getAndIncrement(): Int], [getAndDecrement(): Int]
igual aos anteriores, mas retornam o valor anterior (como [x++] e [x--])
[addAndGet(delta: Int): Int]
soma [delta] ao valor e retorna o novo valor
[getAndSet(v: Int): Int]
atribui [v] e retorna o valor antigo
[compareAndSet(expected: Int, new: Int): Boolean]
atribui [new] somente se o valor for [expected]; retorna [true] se a atribuição ocorreu
[updateAndGet(f: IntUnaryOperator): Int]
substitui o valor v por f(v) de forma atômica e retorna o novo valor; no Kotlin, passa-se a ele uma lambda: [a.updateAndGet { it * 2 }]

O pacote também oferece [AtomicLong], [AtomicBoolean], [AtomicReference<V>] (uma referência atômica a um objeto) e arrays atômicos ([AtomicIntegerArray]…). A classe [LongAdder] (Java 8) é um contador projetado para atualizações muito frequentes feitas por muitas threads: em vez de uma única variável disputada por todas as threads, ela distribui os incrementos por várias células, que só são somadas quando o total é solicitado ([sum]).

A biblioteca padrão do Kotlin 2.4 também tem suas próprias classes atômicas, comuns a todas as plataformas Kotlin ([AtomicInt], [AtomicLong], [AtomicReference]… do pacote [kotlin.concurrent.atomics]), mas elas ainda são experimentais: o compilador exige adesão explícita ([@OptIn(ExperimentalAtomicApi::class)]). Para a JVM, usamos portanto as do JDK.

O programa [Threads17.kt] retoma os resultados do programa [Threads09.kt] e compara seis maneiras de incrementar o contador compartilhado:

// classes atômicas: operações sem lock
package threads17

import java.util.concurrent.CountDownLatch
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.LongAdder
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock

// o recurso compartilhado
object Counter {
    // @Volatile garante a visibilidade das escritas, não a atomicidade de value++
    @Volatile
    var value = 0
    private val lock = Any()
    private val reentrantLock = ReentrantLock()
    val atomic = AtomicInteger()
    val adder = LongAdder()

    // reinicialização dos contadores
    fun reset() {
        value = 0
        atomic.set(0)
        adder.reset()
    }

    // ler, incrementar, escrever: não atômico
    fun withoutSynchronization() {
        value++
    }

    // seção crítica protegida por synchronized
    fun withSynchronized() {
        synchronized(lock) {
            value++
        }
    }

    // função synchronized: o lock é o próprio objeto Counter
    @Synchronized
    fun withSynchronizedAnnotation() {
        value++
    }

    // seção crítica protegida por um ReentrantLock
    fun withReentrantLock() {
        reentrantLock.withLock {
            value++
        }
    }

    // incremento atômico, sem lock
    fun withAtomicInteger() {
        atomic.incrementAndGet()
    }

    // incremento de um somador distribuído, sem lock
    fun withLongAdder() {
        adder.increment()
    }
}

fun main(args: Array<String>) {
    // parâmetros: número de threads, número de incrementos por thread
    val nbThreads = args.getOrNull(0)?.toInt() ?: 4
    val nbIncrements = args.getOrNull(1)?.toInt() ?: 10_000_000
    println("%d threads, %,d increments per thread, expected value %,d"
        .format(nbThreads, nbIncrements, nbThreads * nbIncrements))

    // seis formas de incrementar um contador compartilhado
    val value = { Counter.value.toLong() }
    measure("without synchronization", nbThreads, nbIncrements, Counter::withoutSynchronization, value)
    measure("with synchronized", nbThreads, nbIncrements, Counter::withSynchronized, value)
    measure("with @Synchronized", nbThreads, nbIncrements, Counter::withSynchronizedAnnotation, value)
    measure("with ReentrantLock", nbThreads, nbIncrements, Counter::withReentrantLock, value)
    measure("with AtomicInteger", nbThreads, nbIncrements, Counter::withAtomicInteger) {
        Counter.atomic.get().toLong()
    }
    measure("with LongAdder", nbThreads, nbIncrements, Counter::withLongAdder, Counter.adder::sum)
}

// inicia as threads que executam todas [increment] nbIncrements vezes e depois exibe [value]
fun measure(method: String, nbThreads: Int, nbIncrements: Int, increment: () -> Unit, value: () -> Long) {
    Counter.reset()
    // um sinal de largada para que todas as threads comecem ao mesmo tempo
    val startSignal = CountDownLatch(1)
    val threads = List(nbThreads) {
        Thread.ofPlatform().start {
            try {
                startSignal.await()
            } catch (_: InterruptedException) {
                return@start
            }
            repeat(nbIncrements) { increment() }
        }
    }
    // já!
    val begin = System.nanoTime()
    startSignal.countDown()
    threads.forEach { it.join() }
    val duration = (System.nanoTime() - begin) / 1_000_000
    println("%-23s : value obtained %,12d in %5d ms".format(method, value(), duration))
}

Comentários:

  • linhas 11–59: o objeto [Counter] reúne os contadores e as seis funções de incremento;
  • linhas 12–14: o contador é [@Volatile]. Isso impede que o compilador realize a otimização em tempo de execução que observamos com [Threads09.kt]: cada incremento realmente lê da memória e escreve nela;
  • linha 29: o incremento não sincronizado;
  • linhas 33–35: o incremento dentro de uma seção crítica protegida pela função [synchronized] e por um lock privado;
  • linhas 40–42: a função [withSynchronizedAnnotation] é anotada com [@Synchronized]: todo o seu corpo é uma seção crítica, cujo lock é o próprio objeto [Counter] ;
  • linhas 46–48: incremento dentro de uma seção crítica protegida por um [ReentrantLock], usando a função [withLock];
  • linha 54: incremento atômico;
  • linha 59: incremento de um [LongAdder];
  • Linhas 71–79: a função [measure] é chamada com seis funções de incremento diferentes, passadas como referências vinculadas ([Counter::withoutSynchronization]…), e com uma função que retorna o valor resultante, do tipo [() -> Long]. Para as quatro primeiras, é a lambda [value] da linha 71 que converte o [Int] do contador em [Long] (não há conversão implícita no Kotlin); para o [AtomicInteger], é uma lambda final; para o [LongAdder], a referência [Counter.adder::sum] está vinculada ao método [sum] de um objeto específico, que já retorna um [Long]. Em Java, era necessário escolher as interfaces funcionais [Runnable] e [LongSupplier]; no Kotlin, os tipos funcionais [() -> Unit] e [() -> Long] são suficientes;
  • Linhas 83–102: a função [measure] inicia [nbThreads] threads, cada uma das quais chama a função recebida [nbIncrements] vezes, e mede o tempo total. O formato [%,12d] alinha o valor à direita em 12 caracteres, com separador de milhares; [%-23s] alinha o nome do método à esquerda em 23 caracteres;
  • Linhas 86, 90 e 99: as threads esperam todas atrás de um *[CountDownLatch]*, que é aberto depois que todas foram iniciadas. Isso permite que comecem seu trabalho simultaneamente, tornando o acesso concorrente muito mais provável do que se as threads fossem iniciadas uma após a outra. Se a espera for interrompida, a instrução [return@start] (linha 92) encerra a lambda passada a [start]: dentro de uma lambda, um simples [return] sairia da função envolvente, o que não é permitido aqui; por isso usamos um rótulo para especificar de qual lambda estamos saindo (Capítulo 7).

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=threads17.Threads17Kt
4 threads, 10,000,000 increments per thread, expected value 40,000,000
without synchronization : value obtained   39,809,654 in  1831 ms
with synchronized       : value obtained   40,000,000 in  4482 ms
with @Synchronized      : value obtained   40,000,000 in  4883 ms
with ReentrantLock      : value obtained   40,000,000 in  4360 ms
with AtomicInteger      : value obtained   40,000,000 in  1588 ms
with LongAdder          : value obtained   40,000,000 in  2143 ms
  • Sem sincronização, o resultado está incorreto mais uma vez: a anotação [@Volatile] não tornou [value++] atômico. O número de atualizações perdidas varia bastante de uma execução para outra;
  • os outros cinco métodos produzem o resultado correto, e isso é reproduzível;
  • as classes atômicas são significativamente mais rápidas que os locks nesta execução. Os locks são caros aqui porque quatro threads competem constantemente por eles em uma operação minúscula. A função [synchronized] e a anotação [@Synchronized] têm custos semelhantes: são duas implementações do mesmo mecanismo, o monitor da JVM. Os tempos de execução medidos dependem muito da máquina e de sua carga (esta máquina tinha apenas dois processadores, intensamente usados por outros programas): só a ordem de grandeza tem significado e, de uma execução para outra, a classificação entre métodos semelhantes muda. [LongAdder] não foi o mais rápido aqui: com dois processadores, as threads interferem pouco entre si ao acessar a única variável de um [AtomicInteger]. Sua vantagem aparece quando vários processadores incrementam o mesmo contador.

O método [compareAndSet] (“CAS”) é o bloco de construção dos algoritmos “sem lock” (lock-free): ele lê o valor, calcula o novo e só o escreve se a variável não tiver mudado nesse meio-tempo; caso contrário, recomeça. É isso que [updateAndGet] faz, e as coleções concorrentes apresentadas mais adiante o utilizam amplamente.

8.8. Acesso concorrente a vários recursos compartilhados

8.8.1. Deadlock

Em nossos exemplos anteriores, um único recurso era compartilhado entre as diferentes threads. A situação se complica quando há vários recursos e eles dependem uns dos outros. Em particular, pode ocorrer um deadlock: duas threads esperam uma pela outra. Considere as seguintes ações, que ocorrem sequencialmente:

  • uma thread T1 adquire o lock V1 para acessar um recurso compartilhado R1;
  • uma thread T2 adquire o lock V2 para acessar um recurso compartilhado R2;
  • a thread T1 solicita o lock V2. Ela fica bloqueada;
  • a thread T2 solicita o lock V1. Ela fica bloqueada.

As threads T1 e T2 esperam uma pela outra indefinidamente. Várias soluções são possíveis:

  • solicitar os dois recursos ao mesmo tempo usando um único lock. Isso nem sempre é possível, se resultar em um bloqueio longo de um recurso custoso;
  • sempre adquirir os locks na mesma ordem: se todas as threads adquirem V1 antes de V2, o deadlock é impossível. Esta é a regra mais utilizada;
  • uma thread que detém V1 e não consegue adquirir V2 libera V1 para evitar o deadlock.

O programa [Threads18.kt] provoca um deadlock e implementa a última solução, usando o método [tryLock] de [ReentrantLock]:

// deadlock: duas threads pegam dois locks em ordem diferente
package threads18

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.TimeUnit
import java.util.concurrent.locks.Lock
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.thread
import kotlin.concurrent.withLock
import kotlin.time.Duration
import kotlin.time.Duration.Companion.seconds

fun main() {
    // os locks dos dois recursos compartilhados
    val lockR1 = ReentrantLock()
    val lockR2 = ReentrantLock()

    // T1 pega R1 e depois solicita R2; desiste após 2 s
    val t1 = thread(name = "T1") { work(lockR1, "R1", lockR2, "R2", 2.seconds) }
    // T2 pega R2 e depois solicita R1; espera até 5 s
    val t2 = thread(name = "T2") { work(lockR2, "R2", lockR1, "R1", 5.seconds) }
    t1.join()
    t2.join()
    println("End of Main")
}

// pega o 1º recurso e depois tenta pegar o 2º durante [timeout]
fun work(first: Lock, firstName: String, second: Lock, secondName: String, timeout: Duration) {
    val name = Thread.currentThread().name
    first.withLock {
        println("${time()} : $name obtained $firstName")
        try {
            // a outra thread recebe tempo para pegar seu primeiro recurso
            Thread.sleep(500)
            println("${time()} : $name requests $secondName")
            // solicitação com tempo máximo de espera, em vez de um lock() que esperaria indefinidamente
            if (second.tryLock(timeout.inWholeMilliseconds, TimeUnit.MILLISECONDS)) {
                try {
                    println("${time()} : $name obtained $secondName" +
                            " and works with $firstName and $secondName")
                } finally {
                    second.unlock()
                }
            } else {
                println("${time()} : $name did not obtain $secondName in ${timeout.inWholeSeconds} s:" +
                        " it releases $firstName and gives up")
            }
        } catch (_: InterruptedException) {
            Thread.currentThread().interrupt()
        }
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 16–17: os locks dos dois recursos. Aqui são variáveis locais, capturadas pelas lambdas das linhas 20 e 22;
  • Linha 20: a thread T1, criada e iniciada pela função [thread], adquire R1 e depois solicita R2; ela espera no máximo 2 segundos. A duração é escrita como [2.seconds]: este é um valor do tipo [kotlin.time.Duration] da biblioteca padrão do Kotlin, construído pela propriedade de extensão [seconds] de [Int] (importada de [Duration.Companion]). É o equivalente de [Duration.ofSeconds(2)] do Java ([java.time.Duration]), porém mais legível;
  • linha 22: a thread T2 adquire R2 e depois solicita R1, isto é, na ordem inversa; ela espera no máximo 5 segundos;
  • linha 29: a função [work] recebe locks do tipo definido pela interface [Lock], que é implementada por [ReentrantLock];
  • linha 31: a thread adquire seu primeiro recurso usando a função [withLock] descrita acima: ela o liberará em qualquer caso ao final do bloco;
  • linha 35: ela espera meio segundo, o que dá à outra thread tempo para adquirir seu próprio primeiro recurso: o deadlock é então garantido;
  • linha 38: em vez de um *[lock] que esperaria indefinidamente, a thread solicita o segundo lock com um tempo máximo de espera. [tryLock] retorna [true] se o lock foi obtido e [false] se o tempo limite expirou. O tempo limite é expresso como um número e uma unidade ([TimeUnit.MILLISECONDS]); a propriedade [inWholeMilliseconds] retorna a duração [timeout] em milissegundos. Não é possível usar aqui [withLock], que chama [lock]: é preciso escrever você mesmo [try { … } finally { second.unlock() }]*;
  • linha 43: um lock adquirido por [tryLock] deve ser liberado por [unlock], dentro de uma cláusula [finally];
  • linhas 45–47: se não foi possível adquirir o segundo lock, a thread aborta. Ao sair do bloco [withLock], ela libera seu primeiro recurso;
  • linhas 49–50: [sleep] e [tryLock] com tempo limite podem lançar [InterruptedException]. O Kotlin não exige que essa exceção seja capturada (ele não tem exceções verificadas), mas uma thread bem escrita o faz e restaura o flag de interrupção, como vimos na seção sobre interrupções.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=threads18.Threads18Kt
13:00:59.694 : T2 obtained R2
13:00:59.692 : T1 obtained R1
13:01:00.204 : T1 requests R2
13:01:00.205 : T2 requests R1
13:01:02.205 : T1 did not obtain R2 in 2 s: it releases R1 and gives up
13:01:02.224 : T2 obtained R1 and works with R2 and R1
End of Main

Cada uma das duas threads obteve seu primeiro recurso e depois solicitou o segundo: elas estão em deadlock. Após 2 segundos, T1 desiste e libera R1; T2, que ainda esperava, obtém imediatamente R1 e pode fazer seu trabalho. Sem um tempo limite, o programa nunca teria terminado. Essa sequência de eventos é reproduzível; apenas a ordem das linhas 1 e 2 e a das linhas 3 e 4 podem mudar (observe, aliás, que as horas nas duas primeiras linhas não estão em ordem: uma thread leu a hora primeiro, mas a outra exibiu sua mensagem primeiro). Não poderíamos escrever este programa usando a função [synchronized], cujo tempo de espera não pode ser limitado.

Quando um programa Kotlin parece estar bloqueado, o comando [jcmd <pid> Thread.print] do JDK exibe a pilha de chamadas de cada uma de suas threads ([pid] é o ID do processo, retornado pelo comando [jcmd] sem nenhum parâmetro); ele detecta deadlocks entre locks e os informa com a mensagem “Found one Java-level deadlock”, seguida das threads e dos locks envolvidos. O depurador do IntelliJ (IDEA) oferece a mesma funcionalidade (botão Get Thread Dump ).

8.8.2. Um exemplo: leitores e escritores

Considere o exemplo a seguir:

  • Temos um array no qual algumas threads escrevem dados (os escritores) e outras os leem (os leitores);
  • os escritores são iguais entre si, mas exclusivos: apenas um escritor por vez pode depositar dados no array;
  • os leitores são iguais entre si, mas exclusivos: apenas um leitor por vez pode ler os dados armazenados no array;
  • um leitor só pode ler dados do array quando um escritor os tiver colocado ali, e um escritor só pode colocar novos dados no array quando os dados que já estão ali tiverem sido lidos por um leitor.

Há dois tipos de recursos compartilhados:

  • o array de escrita: apenas um escritor por vez pode acessá-lo;
  • o array de leitura: apenas um leitor por vez pode acessá-lo.

e uma ordem de uso desses recursos:

  • um leitor deve sempre vir depois de um escritor;
  • um escritor deve sempre vir depois de um leitor, exceto na primeira vez.

O acesso a esses dois recursos pode ser controlado por duas barreiras do tipo [Semaphore]:

  • a barreira [canWrite] controla o acesso dos escritores ao array;
  • a barreira [canRead] controla o acesso dos leitores ao array;
  • a barreira [canWrite] é criada no estado aberto (uma permissão), deixando passar o primeiro escritor e bloqueando todos os outros;
  • a barreira [canRead] é criada no estado fechado (nenhuma permissão), bloqueando todos os leitores;
  • quando um escritor termina seu trabalho, ele abre a barreira [canRead] para deixar entrar um leitor;
  • quando um leitor termina seu trabalho, ele abre a barreira [canWrite] para deixar entrar um escritor.

Aqui vemos a vantagem de uma barreira que não pertence a nenhuma thread: a barreira [canRead] é fechada por um leitor (que pega a permissão) e aberta por um escritor (que a devolve). Isso é impossível com um lock, que só pode ser liberado pela thread que o detém. O programa [Threads19.kt] que ilustra essa sincronização é o seguinte:

// leitores e escritores sincronizados por dois semáforos
package threads19

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.Semaphore
import kotlin.concurrent.thread
import kotlin.random.Random

fun main() {
    // o número de threads de cada tipo
    val nbThreads = 2

    // criação e início das threads leitoras
    repeat(nbThreads) { i -> thread(name = "R$i") { Board.read() } }
    // criação e início das threads escritoras
    repeat(nbThreads) { i -> thread(name = "W$i") { Board.write() } }
    // fim de main: as outras threads continuam seu trabalho
    println("End of Main...")
}

// o recurso compartilhado e sua sincronização
object Board {
    // o array compartilhado entre leitores e escritores
    private val data = IntArray(3)
    // sinaliza que o conteúdo de data pode ser lido: fechado no início (sem permissão)
    private val canRead = Semaphore(0)
    // sinaliza que data pode ser escrito: aberto no início (uma permissão)
    private val canWrite = Semaphore(1)

    // ler o conteúdo do array
    fun read() {
        val name = Thread.currentThread().name
        println("Function [read] started by thread $name")
        // esperamos a permissão de leitura
        canRead.acquireUninterruptibly()
        // leitura do array
        for (number in data) {
            // espera de 0,5 s: a thread perde o processador
            sleep(500)
            println("${time()} : reader $name read the number $number")
        }
        // um escritor é autorizado
        canWrite.release()
        println("Function [read] finished by thread $name")
    }

    // escrever no array
    fun write() {
        val name = Thread.currentThread().name
        println("Function [write] started by thread $name")
        // esperamos a permissão de escrita
        canWrite.acquireUninterruptibly()
        // escrita do array
        for (i in data.indices) {
            // espera de 0,5 s
            sleep(500)
            // um número aleatório no intervalo [0, 1000[
            data[i] = Random.nextInt(0, 1000)
            println("${time()} : writer $name wrote the number ${data[i]}")
        }
        // um leitor é autorizado
        canRead.release()
        println("Function [write] finished by thread $name")
    }
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 15–17: criação e inicialização de duas threads leitoras, seguidas de duas threads escritoras. A função [repeat] executa sua lambda [nbThreads] vezes, passando a ela o número da iteração atual. Nenhuma referência às threads é mantida: a thread principal não espera por elas;
  • linha 19: a thread principal termina imediatamente. O processo continua até que as quatro threads — que não são daemons — tenham terminado;
  • linha 23: o recurso compartilhado e sua sincronização são agrupados em um objeto singleton, como o objeto [Counter] dos programas anteriores (o Java usava uma classe aninhada com membros [static]);
  • linha 25: o array [data], um [IntArray] de três elementos (compilado como [int[]]), é o recurso compartilhado entre as threads leitoras e escritoras;
  • linha 27: a barreira [canRead] sinaliza aos leitores que eles podem ler o array. Ela é aberta pelo escritor que preencheu o array. É criada no estado fechado: um escritor precisa primeiro preencher o array;
  • linha 29: a barreira [canWrite] avisa aos escritores que eles podem escrever no array. Ela é aberta pelo leitor que leu o array inteiro. É criada aberta: o array pode ser escrito desde o início;
  • linha 36: um leitor espera que um escritor sinalize que o array foi preenchido. Quando esse sinal chega, apenas um dos leitores em espera prossegue;
  • linhas 38–41: o array é lido, com uma pausa de meio segundo a cada elemento para forçar a thread a ceder a CPU;
  • linha 44: o leitor avisa aos escritores que o array foi lido e pode ser preenchido novamente;
  • a função [write] é simétrica à função [read]. O laço da linha 55 percorre os índices do array (***[data.indices] é o intervalo ***[0..2]);
  • linha 59: os números são gerados aleatoriamente pelo objeto [Random] da biblioteca padrão do Kotlin ([kotlin.random.Random]). A função [nextInt(0, 1000)] retorna um inteiro do intervalo [0, 1000[. O gerador [Random] pode ser usado por várias threads: na JVM, ele se baseia na classe [ThreadLocalRandom] (Java 7), que fornece a cada thread seu próprio gerador, de modo que as threads não disputem um único gerador. O código Java usava [ThreadLocalRandom.current().nextInt(0, 1000)] diretamente;
  • o array [data] não é protegido por nenhum lock. No entanto, não há data race: as escritas do escritor precedem seu [canRead.release()], que precede (relação happens-before) o [canRead.acquireUninterruptibly()] do leitor e, portanto, suas leituras.

Resultados:

> gradlew -q run -Pmain=threads19.Threads19Kt
Function [read] started by thread R1
Function [write] started by thread W0
End of Main...
Function [write] started by thread W1
Function [read] started by thread R0
12:46:35.516 : writer W0 wrote the number 760
12:46:36.029 : writer W0 wrote the number 133
12:46:36.530 : writer W0 wrote the number 35
Function [write] finished by thread W0
12:46:37.031 : reader R1 read the number 760
12:46:37.532 : reader R1 read the number 133
12:46:38.032 : reader R1 read the number 35
Function [read] finished by thread R1
12:46:38.533 : writer W1 wrote the number 277
12:46:39.033 : writer W1 wrote the number 724
12:46:39.534 : writer W1 wrote the number 375
Function [write] finished by thread W1
12:46:40.035 : reader R0 read the number 277
12:46:40.536 : reader R0 read the number 724
12:46:41.036 : reader R0 read the number 375
Function [read] finished by thread R0

Vale a pena observar os seguintes pontos:

  • há apenas um leitor por vez, embora ele perca a CPU na seção crítica [read];
  • há apenas um escritor por vez, embora ele perca o processador na seção crítica [write];
  • um leitor só lê quando há algo a ser lido no array;
  • um escritor só escreve quando o array foi totalmente lido;
  • no entanto, a ordem de execução não pode ser controlada: aqui, o leitor R1 foi executado antes do leitor R0, embora R0 tivesse sido iniciado primeiro; também não havia nenhum motivo para que o escritor W0 fosse executado antes do escritor W1. Uma execução diferente pode resultar em uma ordem diferente.

8.8.3. Os métodos wait e notifyAll

No exemplo anterior, quando os escritores estão bloqueados na instrução [canWrite.acquireUninterruptibly()], um deles — qualquer um — é desbloqueado pela operação [canWrite.release()]. Se quisermos abrir a barreira para um escritor específico, as coisas se complicam.

Considere a analogia de uma repartição pública com guichês de atendimento. Quando um cliente chega, ele retira uma senha numerada no dispensador e vai se sentar. Os clientes são chamados pelo número por um alto-falante. Enquanto espera, o cliente pode fazer o que quiser: ler ou cochilar. Ele é despertado toda vez que o alto-falante anuncia um número. Se for o seu número, o cliente se levanta e vai ao guichê; caso contrário, volta ao que estava fazendo. Podemos proceder de maneira semelhante com threads. Vejamos o exemplo dos escritores:

No guichê
Com threads
vários escritores esperam pelo mesmo guichê
suas threads estão bloqueadas
o guichê fica disponível e o número do próximo escritor é chamado
a thread que estava lendo o array avisa aos escritores que o array está disponível. Essa thread ou outra determinou qual escritor deve prosseguir
Cada escritor verifica seu número; apenas aquele cujo número foi chamado vai ao guichê; os demais voltam para a fila de espera
Cada thread verifica se é a selecionada. Se for, passa pela barreira; caso contrário, volta para a fila de espera

A JVM permite implementar esse cenário usando métodos disponíveis para qualquer objeto Java, já que eles são definidos na classe [java.lang.Object]:

Método
Função
[wait()]
devolve o monitor do objeto e bloqueia a thread até que outra thread sinalize uma mudança por meio de [notify] ou [notifyAll]; a thread deve então reaver o monitor antes de continuar. A espera pode ser interrompida ([InterruptedException])
[wait(ms: Long)]
igual ao anterior, com um tempo máximo de espera
[notify()]
desperta uma das threads bloqueadas por [wait] neste objeto
[notifyAll()]
desperta todas as threads bloqueadas por [wait] neste objeto

Em Kotlin, esses métodos não são diretamente acessíveis. A classe raiz do Kotlin é [Any], e não [Object]: o compilador mapeia os dois tipos (um *[Any] é compilado como *[java.lang.Object]*), mas *[Any] declara apenas três funções: *[equals]*, [hashCode], e [toString]. Os métodos [wait], [notify], e [notifyAll] (assim como [getClass]) são intencionalmente omitidos: os projetistas do Kotlin consideraram que esse mecanismo de baixo nível não deveria poluir todos os objetos e que era melhor usar as ferramentas fornecidas por [java.util.concurrent]. Se escrevermos, usando um token [val token = Any()]:

synchronized(token) { token.wait() }

o compilador responde com:

error: unresolved reference 'wait' on receiver of type 'Any'.

Para chamar [wait], é preciso um objeto cujo tipo, do ponto de vista do compilador, seja [java.lang.Object]. Você pode converter o tipo com [(token as Object).wait()] ou criar o token diretamente usando [Object()]. Em ambos os casos, o compilador emite um aviso:

warning: this class is not recommended for use in Kotlin. Use 'kotlin.Any' instead.

Como nossos programas são compilados com a opção que converte avisos em erros ([allWarningsAsErrors = true]), o aviso deve ser desativado explicitamente adicionando a anotação [@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")] à declaração que usa a classe [Object] ([PLATFORM_CLASS_MAPPED_TO_KOTLIN] é o nome desse aviso: “classe de plataforma associada a uma classe Kotlin”). Fazemos isso uma vez por todas, a seguir, na declaração do token: seu tipo passa a ser [java.lang.Object], e as chamadas [token.wait()] e [token.notifyAll()] deixam de gerar aviso. Esse pequeno inconveniente é intencional: em Kotlin, preferimos a interface [Condition], apresentada na próxima seção. Mesmo assim, é útil conhecer [wait] e [notifyAll], que aparecem em muito código Java existente.

Descreveremos agora um padrão clássico — apresentado em especial no livro de Brian Goetz et al., [Java Concurrency in Practice] — que permite resolver problemas de barreira com condições de entrada.

As threads que compartilham um recurso (o contador) o acessam por meio de um objeto que chamaremos de token: trata-se de um objeto simples ([Object()]) cujo monitor é utilizado. Para atravessar a barreira que dá acesso ao contador, é preciso possuir o token, e existe apenas um. As threads precisam, portanto, passar o token de uma para outra.

Para ir ao contador, uma thread primeiro solicita o token usando um bloco [synchronized(token) { … }]. Se obtiver o token, ela verifica se satisfaz a condição para seguir ao contador em um laço [while (!iAmTheExpectedOne) { token.wait() }] e depois segue ao contador, ainda dentro do bloco [synchronized]. Se a thread não for a esperada no contador, ela cede a vez devolvendo o token por meio de [token.wait()] e entra no estado bloqueado. Ela será despertada quando outra thread sinalizar uma mudança na condição de acesso; então recuperará o token e verificará a condição novamente. É por isso que o teste é um laço ([while]) e não um simples [if]. Há uma segunda razão, específica da JVM: a especificação admite “despertares espúrios”, em que [wait] termina sem que nenhuma thread tenha chamado [notify]; o laço os torna inofensivos. A operação [token.wait()] só pode ser executada por uma thread que detém o monitor do token; caso contrário, uma exceção [IllegalMonitorStateException] é lançada. Nesse esquema, o token só é liberado depois que a transação termina.

A thread que modifica a condição de acesso ao contador também deve deter o token e notificar as threads em espera: dentro de um bloco [synchronized(token) { … }], ela modifica a condição de acesso ao contador e depois desperta as threads em espera com [token.notifyAll()].

Despertar as threads significa que as threads em espera se tornam candidatas ao token; elas não o recebem imediatamente. O token só fica disponível ao final do bloco [synchronized]. Todas as threads despertadas receberão então o token, uma de cada vez, em ordem indeterminada, o que lhes dá a oportunidade de verificar novamente a condição de acesso. A primeira que satisfizer a condição mantém o token e segue para o guichê.

Com essas informações, podemos reescrever a aplicação de leitores/escritores especificando a ordem em que leitores e escritores seguem para seus respectivos guichês ([Threads20.kt]):

// leitores e escritores acessando o contador em uma ordem imposta: wait / notifyAll
package threads20

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.concurrent.thread
import kotlin.random.Random

fun main() {
    // o número de threads de cada tipo
    val nbThreads = 3

    // a ordem dos leitores: o inverso da ordem de criação
    Board.readOrder = List(nbThreads) { i -> "R${nbThreads - 1 - i}" }
    // a ordem dos escritores: a ordem de criação
    Board.writeOrder = List(nbThreads) { i -> "W$i" }
    for (i in 0..<nbThreads) {
        println("Reader ${Board.readOrder[i]} is in position $i," +
                " writer ${Board.writeOrder[i]} is in position $i")
    }

    // criação e início das threads leitoras e depois das threads escritoras
    repeat(nbThreads) { i -> thread(name = "R$i") { Board.read() } }
    repeat(nbThreads) { i -> thread(name = "W$i") { Board.write() } }

    // permissão de escrita
    Board.allowWriting()
    // fim de main
    println("End of Main...")
}

// o recurso compartilhado e sua sincronização
object Board {
    // o array compartilhado entre leitores e escritores
    private val data = IntArray(3)
    // os tokens de acesso dos contadores de leitura e de escrita:
    // objetos java.lang.Object, para ter wait e notifyAll
    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
    private val canRead = Object()
    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
    private val canWrite = Object()
    // as condições de acesso dos contadores
    private var readingAllowed = false
    private var writingAllowed = false
    private var nextReader = 0
    private var nextWriter = 0
    // a ordem dos leitores e dos escritores
    var readOrder = listOf<String>()
    var writeOrder = listOf<String>()

    // abre o contador de escrita
    fun allowWriting() {
        synchronized(canWrite) {
            writingAllowed = true
            // acordamos todos os escritores que esperam pelo token
            canWrite.notifyAll()
        }
    }

    // ler o conteúdo do array
    fun read() {
        val name = Thread.currentThread().name
        println("Function [read] started by thread $name")
        // o token do contador de leitura é solicitado
        synchronized(canRead) {
            try {
                // enquanto não for a nossa vez, devolvemos o token e esperamos
                while (!readingAllowed || readOrder[nextReader] != name) {
                    canRead.wait()
                }
            } catch (_: InterruptedException) {
                return
            }
            // no contador: leitura do array
            for (number in data) {
                sleep(500)
                println("${time()} : reader $name read the number $number")
            }
            // próximo leitor
            readingAllowed = false
            nextReader++
            // os escritores são avisados de que podem escrever
            synchronized(canWrite) {
                writingAllowed = true
                canWrite.notifyAll()
            }
            println("Function [read] finished by thread $name")
        }
    }

    // escrever no array
    fun write() {
        val name = Thread.currentThread().name
        println("Function [write] started by thread $name")
        // o token do contador de escrita é solicitado
        synchronized(canWrite) {
            try {
                // enquanto não for a nossa vez, devolvemos o token e esperamos
                while (!writingAllowed || writeOrder[nextWriter] != name) {
                    canWrite.wait()
                }
            } catch (_: InterruptedException) {
                return
            }
            // no contador: escrita do array
            for (i in data.indices) {
                sleep(500)
                data[i] = Random.nextInt(0, 1000)
                println("${time()} : writer $name wrote the number ${data[i]}")
            }
            // próximo escritor
            writingAllowed = false
            nextWriter++
            // os leitores são avisados de que podem ler
            synchronized(canRead) {
                readingAllowed = true
                canRead.notifyAll()
            }
            println("Function [write] finished by thread $name")
        }
    }
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

O acesso ao guichê de leitura é condicionado pelos seguintes elementos:

  • linha 39: o token [canRead], precedido (na linha 38) pela anotação que desativa o aviso sobre a classe [Object];
  • linha 43: o valor booleano [readingAllowed];
  • linha 48: a lista ordenada dos nomes dos leitores. Os leitores seguem para o guichê de leitura na ordem dessa lista;
  • linha 45: [nextReader] é o índice, nessa lista, do próximo leitor autorizado a seguir para o guichê.

O acesso ao guichê de escrita é controlado de maneira semelhante pelo token [canWrite], pelo booleano [writingAllowed], pela lista [writeOrder], e pelo índice [nextWriter].

O programa principal:

  • linhas 14–16: os leitores seguirão para o guichê na ordem inversa de sua criação (R2, R1, R0), e os escritores na ordem em que foram criados (W0, W1, W2). As listas são construídas pela função [List], que chama sua lambda para cada índice. O código Java usava um stream ([IntStream.range(0, nbThreads).mapToObj(…).toList()]);
  • linha 17: o intervalo [0..<nbThreads] exclui seu limite superior: ele equivale a [0 until nbThreads];
  • linhas 23–24: criação e inicialização dos leitores, seguidos dos escritores. Todos ficarão bloqueados, pois nem a leitura nem a escrita são permitidas;
  • linha 27: a escrita é habilitada e os escritores são notificados de que algo mudou (função [allowWriting], linhas 52–56).

A função [read]:

  • linhas 65–87: todo o processo no guichê de leitura é controlado pelo bloco [synchronized] sobre o token [canRead]. O leitor que o obtém o mantém durante toda a sua permanência no guichê;
  • linhas 68–69: um leitor que adquiriu o token o devolve se a leitura não for permitida ou se não for a sua vez. Os nomes são comparados pelo operador [!=], que compara o conteúdo (ele chama [equals]);
  • linhas 71–72: se a thread for interrompida durante a espera, ela aborta. O [return] é escrito aqui na lambda passada a [synchronized]; isso é permitido porque [synchronized] é uma função [inline] (Capítulo 7): esse [return] termina a função [read], e o monitor é liberado no processo;
  • linhas 75–77: seguir para o guichê (ler a tabela);
  • linhas 80–81: o leitor altera as condições de acesso ao guichê de leitura. Ele ainda detém o token de leitura, e essas alterações impedem que qualquer outro leitor acesse o guichê;
  • linhas 83–85: o leitor altera as condições de acesso ao guichê de escrita e notifica todos os escritores em espera de que algo mudou. Para isso, ele pega o token [canWrite]: aqui vemos que a thread detém dois tokens ao mesmo tempo. Os escritores fazem o mesmo na ordem inversa (eles detêm [canWrite] e solicitam [canRead]), que é a situação de deadlock descrita anteriormente. No entanto, não há risco aqui: uma thread solicita o segundo token apenas ao final de sua passagem pelo guichê; os dois guichês nunca estão ocupados ao mesmo tempo; e as demais threads detêm um token apenas o tempo necessário para verificar a condição de acesso, sem solicitar o outro token.

A função [write] é simétrica à função [read]. Observe o uso de [notifyAll] em vez de [notify], que desperta apenas uma thread: se essa thread não fosse o escritor esperado, ela voltaria a dormir, e o escritor esperado poderia nunca ser despertado. Com uma condição de acesso que designa uma thread específica, é preciso usar [notifyAll].

Eis um exemplo de execução:

> gradlew -q run -Pmain=threads20.Threads20Kt
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Function [read] started by thread R1
Function [read] started by thread R0
Function [read] started by thread R2
End of Main...
Function [write] started by thread W2
Function [write] started by thread W0
Function [write] started by thread W1
12:48:13.264 : writer W0 wrote the number 320
12:48:13.798 : writer W0 wrote the number 344
12:48:14.311 : writer W0 wrote the number 403
Function [write] finished by thread W0
12:48:14.812 : reader R2 read the number 320
12:48:15.312 : reader R2 read the number 344
12:48:15.813 : reader R2 read the number 403
Function [read] finished by thread R2
12:48:16.327 : writer W1 wrote the number 301
12:48:16.827 : writer W1 wrote the number 270
12:48:17.328 : writer W1 wrote the number 102
Function [write] finished by thread W1
12:48:17.835 : reader R1 read the number 301
12:48:18.335 : reader R1 read the number 270
12:48:18.839 : reader R1 read the number 102
Function [read] finished by thread R1
12:48:19.343 : writer W2 wrote the number 402
12:48:19.844 : writer W2 wrote the number 589
12:48:20.344 : writer W2 wrote the number 985
Function [write] finished by thread W2
12:48:20.859 : reader R0 read the number 402
12:48:21.360 : reader R0 read the number 589
12:48:21.861 : reader R0 read the number 985
Function [read] finished by thread R0

Escritores e leitores se revezam em seus guichês, cada um na ordem especificada: W0, R2, W1, R1, W2, R0. Ao contrário do programa anterior, essa ordem de atendimento é reprodutível; apenas a ordem das mensagens “started” varia de uma execução para outra.

8.8.4. Condições: a interface Condition

Os métodos [wait] e [notifyAll] estão associados ao monitor de um objeto e, portanto, aos blocos [synchronized]. Para um lock [ReentrantLock], o equivalente é a interface [java.util.concurrent.locks.Condition]: um objeto [Condition] é criado pelo método [newCondition()] do lock e fornece os métodos [await()] (o equivalente de [wait]), [await(time: Long, unit: TimeUnit)], [signal()] (o equivalente de [notify]) e [signalAll()] (o equivalente de [notifyAll]). Seu uso segue as mesmas regras: a thread deve deter o lock, e a condição de acesso é testada dentro de um laço [while]. Esses são métodos comuns de uma interface Java: o Kotlin os chama sem conversão de tipo nem avisos. Essa é a solução preferida em Kotlin.

A principal vantagem é que um único lock pode ter várias condições — isto é, várias filas distintas. No nosso problema, um único lock pode proteger os dois guichês, com uma condição para os leitores e outra para os escritores: um leitor que termina desperta os escritores, e somente eles. Não há mais dois tokens, portanto não há mais aninhamento de locks a vigiar. O programa [Threads21.kt] tem o mesmo programa principal que [Threads20.kt]; seu objeto [Board] é o seguinte:

// o recurso compartilhado e sua sincronização
object Board {
    // o array compartilhado entre leitores e escritores
    private val data = IntArray(3)
    // um único lock para os dois contadores
    private val lock = ReentrantLock()
    // duas condições associadas a este lock: duas filas de espera distintas
    private val canRead = lock.newCondition()
    private val canWrite = lock.newCondition()
    // as condições de acesso dos contadores
    private var readingAllowed = false
    private var writingAllowed = false
    private var nextReader = 0
    private var nextWriter = 0
    // a ordem dos leitores e dos escritores
    var readOrder = listOf<String>()
    var writeOrder = listOf<String>()

    // abre o contador de escrita
    fun allowWriting() {
        lock.withLock {
            writingAllowed = true
            // acordamos todos os escritores, e somente eles
            canWrite.signalAll()
        }
    }

    // ler o conteúdo do array
    fun read() {
        val name = Thread.currentThread().name
        println("Function [read] started by thread $name")
        lock.withLock {
            try {
                // enquanto não for a nossa vez, devolvemos o lock e esperamos um sinal
                while (!readingAllowed || readOrder[nextReader] != name) {
                    canRead.await()
                }
            } catch (_: InterruptedException) {
                Thread.currentThread().interrupt()
                return
            }
            // no contador: leitura do array
            for (number in data) {
                sleep(500)
                println("${time()} : reader $name read the number $number")
            }
            // próximo leitor
            readingAllowed = false
            nextReader++
            // os escritores são avisados de que podem escrever
            writingAllowed = true
            canWrite.signalAll()
            println("Function [read] finished by thread $name")
        }
    }

    // escrever no array
    fun write() {
        val name = Thread.currentThread().name
        println("Function [write] started by thread $name")
        lock.withLock {
            try {
                // enquanto não for a nossa vez, devolvemos o lock e esperamos um sinal
                while (!writingAllowed || writeOrder[nextWriter] != name) {
                    canWrite.await()
                }
            } catch (_: InterruptedException) {
                Thread.currentThread().interrupt()
                return
            }
            // no contador: escrita do array
            for (i in data.indices) {
                sleep(500)
                data[i] = Random.nextInt(0, 1000)
                println("${time()} : writer $name wrote the number ${data[i]}")
            }
            // próximo escritor
            writingAllowed = false
            nextWriter++
            // os leitores são avisados de que podem ler
            readingAllowed = true
            canRead.signalAll()
            println("Function [write] finished by thread $name")
        }
    }
}

Comentários:

  • linha 6: um único lock, não justo;
  • linhas 8–9: duas condições criadas a partir desse lock. Seu tipo, [Condition], é inferido;
  • linhas 20–24: para abrir o guichê de escrita, adquire-se o lock com a função [withLock], modifica-se a condição de acesso e despertam-se os escritores com [canWrite.signalAll()];
  • linhas 32–53: a passagem para o guichê de leitura ocorre enquanto se detém o lock. A função [withLock] substitui o esquema Java [lock] / [try] / [finally] / [unlock];
  • linhas 35–36: até chegar a sua vez, o leitor espera na condição [canRead]. O método [await] libera o lock durante a espera e o readquire antes de devolver o controle;
  • linhas 38–40: se a thread for interrompida durante a espera, ela restaura seu indicador de interrupção e termina. Como [withLock] é uma função [inline], [return] termina a função [read], e a cláusula [finally] dentro de [withLock] libera o lock no processo;
  • linhas 51–52: o leitor concede a permissão de escrita e desperta os escritores. Ele já detém o lock, portanto não precisa adquirir um segundo token.

Resultados:

> gradlew -q run -Pmain=threads21.Threads21Kt
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Function [read] started by thread R1
Function [read] started by thread R0
Function [write] started by thread W0
End of Main...
Function [write] started by thread W2
Function [read] started by thread R2
Function [write] started by thread W1
12:49:39.079 : writer W0 wrote the number 955
12:49:39.671 : writer W0 wrote the number 213
12:49:40.173 : writer W0 wrote the number 22
Function [write] finished by thread W0
12:49:40.674 : reader R2 read the number 955
12:49:41.177 : reader R2 read the number 213
12:49:41.677 : reader R2 read the number 22
Function [read] finished by thread R2
12:49:42.179 : writer W1 wrote the number 31
12:49:42.680 : writer W1 wrote the number 113
12:49:43.180 : writer W1 wrote the number 999
Function [write] finished by thread W1
12:49:43.683 : reader R1 read the number 31
12:49:44.183 : reader R1 read the number 113
12:49:44.684 : reader R1 read the number 999
Function [read] finished by thread R1
12:49:45.187 : writer W2 wrote the number 528
12:49:45.687 : writer W2 wrote the number 477
12:49:46.188 : writer W2 wrote the number 473
Function [write] finished by thread W2
12:49:46.689 : reader R0 read the number 528
12:49:47.190 : reader R0 read the number 477
12:49:47.690 : reader R0 read the number 473
Function [read] finished by thread R0

O comportamento é idêntico ao do programa anterior: W0, R2, W1, R1, W2, R0.

8.8.5. Vários leitores simultâneos: ReadWriteLock

Nos exemplos anteriores, os leitores eram exclusivos. Em muitas aplicações, isso é desnecessariamente restritivo: várias threads podem ler dados ao mesmo tempo, desde que ninguém os esteja modificando. Apenas as escritas precisam ser exclusivas: enquanto um escritor modifica os dados, nenhum leitor nem outro escritor deve poder acessá-los. Este é o clássico problema dos leitores-escritores, resolvido pela interface [java.util.concurrent.locks.ReadWriteLock]. Um objeto [ReadWriteLock] fornece dois locks associados:

  • [readLock()]: o lock de leitura, que pode ser detido por várias threads ao mesmo tempo, desde que nenhuma thread detenha o lock de escrita;
  • [writeLock()]: o lock de escrita, que é exclusivo.

A biblioteca padrão do Kotlin adiciona duas funções de extensão do pacote [kotlin.concurrent] à classe [ReentrantReadWriteLock] — que implementa essa interface — análogas a [withLock]: [read { … }] executa o bloco enquanto detém o lock de leitura, e [write { … }] executa o bloco enquanto detém o lock de escrita; ambas liberam o lock ao final do bloco e retornam o valor do bloco. O programa [Threads22.kt] é o seguinte:

// vários leitores simultâneos, um único escritor: ReentrantReadWriteLock
package threads22

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.locks.ReentrantReadWriteLock
import kotlin.concurrent.read
import kotlin.concurrent.thread
import kotlin.concurrent.write

fun main() {
    val catalog = Catalog()
    // três leitores consultam o preço do teclado duas vezes
    val readers = List(3) { i ->
        thread(name = "R$i") {
            catalog.readPrice("keyboard")
            catalog.readPrice("keyboard")
        }
    }
    // um escritor, iniciado 0,5 s depois, altera esse preço
    Thread.sleep(500)
    val writer = thread(name = "W") { catalog.changePrice("keyboard", 25) }
    // esperar o fim de todas as threads
    (readers + writer).forEach { it.join() }
}

// o recurso compartilhado: um catálogo de preços
class Catalog {
    private val prices = mutableMapOf("keyboard" to 20, "mouse" to 10)
    // um lock para os leitores, um lock para os escritores
    private val lock = ReentrantReadWriteLock()

    // várias threads podem deter o lock de leitura ao mesmo tempo
    fun readPrice(article: String): Int = lock.read {
        val name = Thread.currentThread().name
        println("${time()} : $name starts reading the price of $article")
        // leitura longa
        sleep(1000)
        val p = prices.getValue(article)
        println("${time()} : $name read the price of $article: $p")
        p
    }

    // o lock de escrita é exclusivo: nenhum leitor, nenhum outro escritor
    fun changePrice(article: String, newPrice: Int) {
        val name = Thread.currentThread().name
        println("${time()} : $name requests the write lock")
        lock.write {
            println("${time()} : $name starts changing the price of $article")
            // escrita longa
            sleep(1000)
            prices[article] = newPrice
            println("${time()} : $name set the price of $article to $newPrice")
        }
    }
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 28–52: o recurso compartilhado é um catálogo de preços, armazenado em um dicionário modificável criado por [mutableMapOf] (linha 29), que é um [LinkedHashMap];
  • linha 31: a classe [ReentrantReadWriteLock];
  • linhas 34–40: a função [readPrice] adquire um lock de leitura para uma operação de leitura que dura um segundo. Seu corpo é uma expressão: o valor retornado por [lock.read { … }], isto é, o valor da última expressão do bloco, [p]. A função [getValue] retorna o valor associado à chave e lança uma exceção [NoSuchElementException] se a chave não existir (o operador [prices[article]] retornaria um [Int?]);
  • linhas 45–53: a função [changePrice] adquire o lock de escrita para uma modificação que dura um segundo. A função Kotlin [write] tem uma particularidade: se a thread já detém o lock de leitura, ela o libera primeiro (caso contrário entraria em deadlock consigo mesma: um [ReentrantReadWriteLock] não permite passar do lock de leitura para o lock de escrita) e o readquire ao final do bloco;
  • linhas 14–17: três leitores leem o preço do teclado duas vezes seguidas;
  • linhas 21–22: um escritor, iniciado meio segundo depois, modifica esse preço;
  • linha 24: o operador [+] constrói uma nova lista formada pelos leitores e pelo escritor, e espera que ela termine.

Resultados:

> gradlew -q run -Pmain=threads22.Threads22Kt
12:50:24.630 : R0 starts reading the price of keyboard
12:50:24.635 : R1 starts reading the price of keyboard
12:50:24.631 : R2 starts reading the price of keyboard
12:50:25.070 : W requests the write lock
12:50:25.643 : R2 read the price of keyboard: 20
12:50:25.651 : R1 read the price of keyboard: 20
12:50:25.651 : R0 read the price of keyboard: 20
12:50:25.652 : W starts changing the price of keyboard
12:50:26.652 : W set the price of keyboard to 25
12:50:26.653 : R1 starts reading the price of keyboard
12:50:26.653 : R0 starts reading the price of keyboard
12:50:26.653 : R2 starts reading the price of keyboard
12:50:27.653 : R0 read the price of keyboard: 25
12:50:27.654 : R2 read the price of keyboard: 25
12:50:27.654 : R1 read the price of keyboard: 25
  • Os três leitores leem ao mesmo tempo (linhas 1–3 e 5–7): com um lock padrão, o primeiro conjunto de leituras teria levado três segundos em vez de um;
  • o escritor, que chegou enquanto as leituras estavam em andamento, esperou até que elas terminassem. Em seguida, alterou o preço sozinho;
  • O segundo conjunto de leitores, que começou depois da chegada do escritor, esperou que a modificação fosse concluída e depois leu o novo preço. O lock [ReentrantReadWriteLock] impede, assim, que um fluxo contínuo de leitores bloqueie indefinidamente a escrita de um escritor: um leitor que chega enquanto um escritor espera passa depois do escritor. Essa sequência é reproduzível; apenas a ordem dos leitores dentro de cada série varia.

Um lock de leitura/escrita só é útil se as leituras forem numerosas e suficientemente longas. Para leituras muito curtas, a classe [StampedLock] (Java 8) oferece uma leitura “otimista” — sem lock — que é validada depois. E, para uma coleção lida com muita frequência, mas raramente modificada, as coleções concorrentes descritas no parágrafo seguinte costumam ser a melhor solução.

8.9. Coleções concorrentes

Os exemplos anteriores protegiam dados compartilhados muito simples (um contador, um array, um pequeno dicionário). Quando as threads compartilham uma coleção (lista, dicionário, fila), seria possível proteger cada acesso com um lock. Mas as coleções mutáveis comuns — as do Kotlin ([mutableListOf], [mutableMapOf], [ArrayDeque]), bem como as do Java ([ArrayList], [HashMap]) — não foram projetadas para ser modificadas por várias threads simultaneamente: o uso sem proteção pode resultar na perda de elementos, provocar exceções inesperadas ([ConcurrentModificationException]) ou até corromper a estrutura interna da coleção. O mesmo vale para as coleções “somente leitura” do Kotlin ([List], [Map]): esse tipo impede que o código que o recebe modifique a coleção, mas não garante que ninguém mais a modifique. Os métodos [Collections.synchronizedList(…)], [Collections.synchronizedMap(…)]… envolvem uma coleção comum em um objeto no qual todo método é do tipo [synchronized]: isso é seguro, mas todas as threads disputam um único lock, e a iteração sobre a coleção ainda precisa ser protegida manualmente. Desde o Java 5, o pacote [java.util.concurrent] oferece coleções projetadas para serem compartilhadas entre threads sem um lock explícito. A biblioteca padrão do Kotlin não tem equivalente para a JVM: usamos diretamente as do JDK, que implementam as interfaces [MutableList] e [MutableMap]… e são, portanto, manipuladas exatamente como as coleções do Kotlin ([+=], [[ ]], [for], [filter], [map]…):

Coleção
Função
[ConcurrentHashMap<K, V>]
Um dicionário cujas operações, incluindo as atualizações condicionais ([merge], [compute], [putIfAbsent]…), são seguras e atômicas. Várias threads podem lê-lo e modificá-lo simultaneamente
[ConcurrentSkipListMap<K, V>]
um dicionário ordenado por chave
[CopyOnWriteArrayList<E>]
uma lista que copia seu array interno a cada modificação: as leituras e os percursos, que são muito rápidos, nunca são afetados pelas modificações. É adequada para listas lidas com frequência e raramente modificadas (listas de reprodução, por exemplo)
[ConcurrentLinkedQueue<E>], [ConcurrentLinkedDeque<E>]
Uma fila (primeiro a entrar, primeiro a sair) e uma fila de duas pontas
[BlockingQueue<E>]
uma interface de fila que bloqueia o consumidor quando a fila está vazia e, se sua capacidade for limitada, bloqueia o produtor quando ela está cheia. Implementações: [ArrayBlockingQueue], [LinkedBlockingQueue], [PriorityBlockingQueue], [SynchronousQueue]…

8.9.1. ConcurrentHashMap e CopyOnWriteArrayList

No programa [Threads23.kt], quatro threads geram números aleatórios e contam quantas vezes cada número aparece em um dicionário compartilhado:

// coleções concorrentes: ConcurrentHashMap e CopyOnWriteArrayList
package threads23

import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
import kotlin.concurrent.thread
import kotlin.random.Random

fun main() {
    // o dicionário compartilhado: dígito -> número de sorteios
    val draws = ConcurrentHashMap<Int, Int>()
    // a lista compartilhada dos relatórios das threads
    val reports = CopyOnWriteArrayList<String>()

    // 4 threads sorteiam cada uma 100.000 dígitos aleatórios
    val nbDraws = 100_000
    val threads = List(4) { i ->
        thread(name = "T$i") {
            repeat(nbDraws) {
                val digit = Random.nextInt(0, 10)
                // adição da chave com o valor 1 ou atualização atômica do valor existente
                draws.merge(digit, 1, Int::plus)
            }
            // relatório adicionado à lista
            val name = Thread.currentThread().name
            reports += "thread %s finished its %,d draws".format(name, nbDraws)
        }
    }
    threads.forEach { it.join() }

    // os relatórios, na ordem de chegada
    for (report in reports) {
        println(report)
    }
    // os resultados dos sorteios, na ordem das chaves
    for ((digit, count) in draws.toSortedMap()) {
        println("digit %d : %,6d draws".format(digit, count))
    }
    val total = draws.values.sum()
    println("total: %,d draws (expected: %,d)".format(total, threads.size * nbDraws))
    // computeIfAbsent: devolve o valor associado à chave, após calculá-lo e adicioná-lo se necessário
    println("computeIfAbsent(10, …) = ${draws.computeIfAbsent(10) { 0 }}, number of keys: ${draws.size}")
}

Comentários:

  • linha 11: o dicionário compartilhado associa cada dígito ao seu número de ocorrências. Os tipos [<Int, Int>] são especificados explicitamente, já que o dicionário é criado vazio;
  • linha 13: uma lista na qual cada thread escreve um relatório ao final de seu trabalho;
  • linha 22: o método [merge(key, value, function)] adiciona a chave [digit] com o valor 1 se ela não existir; caso contrário, substitui seu valor v por [function(v, 1)], aqui a adição, indicada pela referência [Int::plus] à função [plus] de [Int] (o operador [+]). Em um [ConcurrentHashMap], a operação é atômica. Não poderíamos escrever [draws[digit] = (draws[digit] ?: 0) + 1]: essa expressão lê o valor e depois escreve o novo, em duas operações, e duas threads poderiam perder uma atualização, como no exemplo [Threads09.kt];
  • linha 26: cada thread adiciona seu relatório à lista usando o operador [+=] (a função [plusAssign] das coleções mutáveis do Kotlin, que chama [add]). A função [format] de [String] formata a mensagem; o formato [%,d] insere o separador de milhares;
  • linhas 32–33: a thread principal itera sobre a lista. A iteração sobre um *[CopyOnWriteArrayList] é feita sobre um instantâneo do array interno: ela nunca lança *[ConcurrentModificationException], mesmo que outras threads modifiquem a lista durante a iteração;
  • linhas 36–37: a função de extensão [toSortedMap] copia o dicionário para um dicionário ordenado (um [TreeMap]) para exibir os números em ordem; o laço [for] decompõe cada entrada em sua chave e seu valor;
  • linha 39: a soma dos valores, calculada pela função [sum] da biblioteca padrão (o Java usava um stream);
  • linha 42: o método [computeIfAbsent(key, function)] retorna o valor associado à chave, depois de calculá-lo com a função e adicioná-lo caso a chave não existisse; a função aqui é uma lambda final, escrita fora dos parênteses. Como em [merge], a verificação e a adição formam uma única operação atômica: uma verificação com [containsKey] seguida de um [put] não seria segura, pois outra thread poderia adicionar a chave nesse intervalo. A função de extensão [getOrPut] do Kotlin, que usamos com dicionários comuns, tem uma versão para dicionários concorrentes ([ConcurrentMap]): ela nunca adiciona um segundo valor para uma chave que já existe, mas sua lambda pode ser chamada desnecessariamente se duas threads adicionarem a mesma chave ao mesmo tempo. [computeIfAbsent] não tem essa desvantagem.

Resultados:

> gradlew -q run -Pmain=threads23.Threads23Kt
thread T1 finished its 100,000 draws
thread T3 finished its 100,000 draws
thread T2 finished its 100,000 draws
thread T0 finished its 100,000 draws
digit 0 : 39,946 draws
digit 1 : 40,200 draws
digit 2 : 39,923 draws
digit 3 : 39,656 draws
digit 4 : 39,825 draws
digit 5 : 40,016 draws
digit 6 : 40,081 draws
digit 7 : 39,907 draws
digit 8 : 40,259 draws
digit 9 : 40,187 draws
total: 400,000 draws (expected: 400,000)
computeIfAbsent(10, …) = 0, number of keys: 11

O número total de sorteios está correto: nenhuma atualização foi perdida. Os relatórios aparecem na ordem em que as threads terminaram seu trabalho, que varia de uma execução para outra, assim como o número de sorteios de cada dígito.

8.9.2. Produtores e consumidores: BlockingQueue

O problema dos leitores e escritores é uma variante do clássico problema do produtor-consumidor: threads produzem dados que outras threads consomem. A interface [BlockingQueue<E>] o resolve sem nenhuma ferramenta de sincronização explícita:

  • [put(element)] coloca um elemento na fila. Se a fila tem capacidade limitada e está cheia, o produtor fica bloqueado até que uma vaga se libere;
  • [take()] remove o elemento da cabeça da fila. Se a fila está vazia, o consumidor fica bloqueado até que um elemento chegue;
  • [offer(element, timeout, unit)] e [poll(timeout, unit)] fazem o mesmo, com um tempo máximo de espera; [offer(element)] e [poll()], que não têm tempo limite, nunca bloqueiam: eles retornam [false] ou [null] em caso de falha (em Kotlin, [poll] retorna um tipo de plataforma, [Int!], que deve ser tratado como um [Int?]).

A fila não sabe que a produção terminou. Uma técnica clássica consiste em colocar na fila, ao final da produção, um valor especial — conhecido em inglês como “poison pill” —: o consumidor que o retira sabe que deve parar. Outra técnica é interromper os consumidores, já que [take] é interrompível. O programa [Threads24.kt] é o seguinte:

// produtor / consumidores com uma BlockingQueue
package threads24

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.BlockingQueue
import kotlin.concurrent.thread

// o valor que sinaliza o fim da produção ("poison pill")
const val END = -1

fun main() {
    // uma fila de no máximo 3 elementos
    val queue: BlockingQueue<Int> = ArrayBlockingQueue(3)
    val nbConsumers = 2

    // o produtor coloca 8 números e depois sinaliza que terminou
    val producer = thread(start = false, name = "P") {
        try {
            for (i in 1..8) {
                // bloqueante se a fila estiver cheia
                queue.put(i)
                println("${time()} : P put $i (waiting elements: ${queue.size})")
                Thread.sleep(100)
            }
            // um marcador de fim por consumidor
            repeat(nbConsumers) { queue.put(END) }
            println("${time()} : P has finished")
        } catch (_: InterruptedException) {
            Thread.currentThread().interrupt()
        }
    }

    // dois consumidores pegam os números até o marcador de fim
    val consumers = List(nbConsumers) { i ->
        thread(start = false, name = "C${i + 1}") {
            val name = Thread.currentThread().name
            try {
                while (true) {
                    // bloqueante se a fila estiver vazia
                    val number = queue.take()
                    if (number == END) break
                    println("${time()} : $name took $number")
                    // processamento do número
                    Thread.sleep(600)
                }
                println("${time()} : $name has finished")
            } catch (_: InterruptedException) {
                Thread.currentThread().interrupt()
            }
        }
    }

    // iniciar e esperar todas as threads
    val all = listOf(producer) + consumers
    all.forEach { it.start() }
    all.forEach { it.join() }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 11: o valor que marca o fim da produção. É uma constante de nível superior, declarada fora de qualquer classe ([const val], Capítulo 3);
  • linha 15: uma fila com no máximo 3 elementos. [ArrayBlockingQueue] armazena os elementos em um array de tamanho fixo; [LinkedBlockingQueue] tem capacidade ilimitada por padrão. A variável é declarada com o tipo da interface, [BlockingQueue<Int>], o que permite ao compilador inferir o tipo dos elementos no construtor [ArrayBlockingQueue(3)];
  • linhas 19–29: o produtor coloca os números de 1 a 8 na fila, um a cada décimo de segundo, seguidos de um marcador de fim para cada consumidor (linha 28). O parâmetro [start = false] da função [thread] cria a thread sem iniciá-la: ela será iniciada mais tarde, junto com os consumidores;
  • linhas 36–48: dois consumidores retiram os números e gastam 0,6 segundo processando cada um. Eles consomem em um ritmo mais lento do que o produtor produz;
  • linha 42: a retirada bloqueante. Cada número é retirado por apenas um dos dois consumidores;
  • linha 43: um consumidor que retira o token de fim sai de seu laço. Cada consumidor retira um token, portanto um token é depositado por consumidor;
  • o produtor e os consumidores contêm a instrução [try], porque [put], [take], e [sleep] podem lançar [InterruptedException]. O Kotlin não exige isso, mas, sem ela, a exceção encerraria a thread exibindo a pilha de chamadas no console;
  • linhas 56–58: inicia todas as threads e depois espera que terminem.

Resultados:

> gradlew -q run -Pmain=threads24.Threads24Kt
12:52:50.226 : P put 1 (waiting elements: 0)
12:52:50.210 : C1 took 1
12:52:50.371 : P put 2 (waiting elements: 1)
12:52:50.374 : C2 took 2
12:52:50.503 : P put 3 (waiting elements: 1)
12:52:50.617 : P put 4 (waiting elements: 2)
12:52:50.737 : P put 5 (waiting elements: 3)
12:52:50.911 : C1 took 3
12:52:50.911 : P put 6 (waiting elements: 3)
12:52:50.974 : C2 took 4
12:52:51.015 : P put 7 (waiting elements: 3)
12:52:51.515 : C1 took 5
12:52:51.517 : P put 8 (waiting elements: 3)
12:52:51.574 : C2 took 6
12:52:52.116 : C1 took 7
12:52:52.118 : P has finished
12:52:52.175 : C2 took 8
12:52:52.716 : C1 has finished
12:52:52.779 : C2 has finished

Vemos o produtor adicionar rapidamente os primeiros números e, depois — assim que a fila contém 3 elementos —, só adicionar um número quando um consumidor retira um: ele fica bloqueado por [put] quando a fila está cheia. Os consumidores dividem os números entre si e param ao retirar o marcador de fim. Esse ritmo é reproduzível; já a atribuição de cada número a C1 ou C2 não é. O produtor exibe “P has finished” somente depois que seus dois marcadores de fim foram colocados, isto é, depois que C1 retirou o número 7 e liberou uma vaga. Notamos também, nas duas primeiras linhas, que o número 1 foi retirado por C1 antes que P exibisse seu depósito (daí “waiting elements: 0”), embora a hora lida por C1 seja anterior à lida por P: cada thread lê a hora e depois a imprime, e outra thread pode se intercalar entre as duas operações.

Veremos esse padrão novamente no próximo capítulo com os canais de corrotinas ([Channel]), que são o equivalente em corrotinas de uma fila bloqueante: suas operações [send] e [receive] suspendem a corrotina em vez de bloquear a thread. Com threads virtuais, um consumidor bloqueado em [take] não ocupa nenhuma thread do sistema.

8.10. Pools de threads: ExecutorService

8.10.1. O princípio

Até agora, para gerenciar threads, nós as criamos e depois as iniciamos, seja por meio de [start()] ou da função [thread]. Criar uma thread de plataforma é uma operação relativamente cara: em particular, o sistema precisa alocar uma pilha para ela, e cada thread ocupa memória enquanto existir. Veremos no Capítulo 10 que existem pools de conexões: as conexões abertas são mantidas em reserva e emprestadas às threads que as solicitam, já que abrir uma conexão é custoso. Existe um sistema semelhante para threads: o pool de threads.

O JDK representa um pool de threads por meio da interface [java.util.concurrent.ExecutorService] (um “executor”): as threads não são mais criadas; em vez disso, tarefas são atribuídas ao executor, que as faz executar por suas threads. Uma thread que concluiu uma tarefa não é destruída; ela assume a tarefa seguinte. A classe [ThreadPoolExecutor], a implementação mais comum, funciona da seguinte maneira:

  • ele tem um número fixo de threads (“core pool size”): enquanto esse número não é atingido, cada nova tarefa provoca a criação de uma nova thread;
  • além disso, as tarefas são colocadas em uma fila (uma [BlockingQueue]) da qual as threads as retiram;
  • se a fila está cheia, o pool cria threads adicionais, até um número máximo (“maximum pool size”). Essas threads adicionais são destruídas se permanecerem inativas por mais de um certo tempo;
  • se o máximo é atingido e a fila está cheia, a tarefa é rejeitada: por padrão, o método que a submeteu lança a exceção [RejectedExecutionException].

O pool de threads oferece duas vantagens: economiza o tempo gasto na criação de threads (algumas threads podem atender centenas de requisições) e, ao limitar o número de threads, impede que a aplicação seja sobrecarregada por requisições em excesso.

Um executor é encerrado por meio de seu método [shutdown] (ele deixa de aceitar novas tarefas, e suas threads param quando as tarefas já submetidas terminam), possivelmente seguido de [awaitTermination] (que espera as tarefas terminarem), ou por [shutdownNow] (que interrompe as tarefas em andamento). A partir do Java 19, [ExecutorService] estende a interface [AutoCloseable]: seu método [close] chama [shutdown] e depois espera que todas as tarefas terminem. Em Kotlin, é possível, portanto, usar um executor dentro de um bloco [use { … }] — a função de extensão de [AutoCloseable] que substitui a instrução [try] com recurso do Java (Capítulo 3) —. Ao sair do bloco, todas as tarefas atribuídas estão concluídas. O programa [Threads25.kt] é o seguinte:

// um pool de threads: ThreadPoolExecutor
package threads25

import java.time.Duration
import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit

// as informações passadas a cada job
data class Data(val number: Int, val start: LocalTime, val duration: Int)

fun main() {
    Thread.currentThread().name = "Main"
    // 3 threads permanentes, no máximo 5 threads, uma fila de espera de 2 jobs
    ThreadPoolExecutor(3, 5, 60, TimeUnit.SECONDS, ArrayBlockingQueue(2)).use { pool ->
        // 8 jobs de 3 s são entregues ao pool
        for (i in 0..<8) {
            val data = Data(i, LocalTime.now(), 3)
            try {
                pool.execute { sleep(data, pool) }
            } catch (_: RejectedExecutionException) {
                println("${time()} : job no. $i was rejected by the pool")
            }
        }
        println("${time()} : thread Main handed the jobs to the pool and waits for their end")
        // o fim do bloco use fecha o pool: close() espera o fim dos jobs submetidos
    }
    println("${time()} : end of thread Main")
}

// o job executado por uma thread do pool
fun sleep(data: Data, pool: ThreadPoolExecutor) {
    // estado do pool
    val name = Thread.currentThread().name
    println("${time()} : job no. ${data.number} starts in thread $name" +
            " (threads: ${pool.poolSize}, active: ${pool.activeCount}, queued: ${pool.queue.size})")
    // dormir por [duration] segundos
    try {
        Thread.sleep(data.duration * 1000L)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
    val duration = Duration.between(data.start, LocalTime.now()).toMillis() / 1000.0
    println("%s : job no. %d ends: scheduled for %d s, it lasted %.2f s since it was requested"
            .format(time(), data.number, data.duration, duration))
}

// a hora atual, em centésimos de segundo
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SS"))

Comentários:

  • linha 18: o pool tem 3 threads permanentes, com um máximo de 5 threads; qualquer thread adicional que esteja inativa por 60 segundos é destruída; a fila de tarefas é uma [ArrayBlockingQueue] com 2 vagas (o tipo de seus elementos, [Runnable], é inferido do parâmetro do construtor). O pool é usado em um bloco [use], que o nomeia [pool];
  • linhas 20–25: 8 jobs, cada um com duração de 3 segundos, são atribuídos ao pool. O método [execute(Runnable)] atribui uma tarefa ao pool sem esperar; a lambda [{ sleep(data, pool) }] é convertida em [Runnable] (conversão SAM, Capítulo 7);
  • linha 21: cada job recebe um objeto [Data]; trata-se de uma data class (linha 13), que tem a mesma finalidade que o [record] do Java;
  • linhas 24–25: um job rejeitado pelo pool provoca a exceção [RejectedExecutionException];
  • linha 29: sair do bloco [use] fecha o pool e espera que os jobs atribuídos terminem;
  • linhas 35–48: o job executado por uma thread do pool. Os nomes das threads ([pool-1-thread-1]…) são atribuídos pelo pool;
  • linha 39: o estado do pool: o número de threads, o número de threads que estão executando uma tarefa e o número de tarefas aguardando na fila. Os métodos Java [getPoolSize], [getActiveCount] e [getQueue] são tratados pelo Kotlin como propriedades: [poolSize], [activeCount], [queue];
  • linha 52: as horas são exibidas com precisão de centésimo de segundo ([SS]).

Resultados:

> gradlew -q run -Pmain=threads25.Threads25Kt
13:01:02.48 : job no. 1 starts in thread pool-1-thread-2 (threads: 3, active: 3, queued: 0)
13:01:02.48 : job no. 2 starts in thread pool-1-thread-3 (threads: 4, active: 4, queued: 2)
13:01:02.48 : job no. 5 starts in thread pool-1-thread-4 (threads: 5, active: 5, queued: 2)
13:01:02.48 : job no. 0 starts in thread pool-1-thread-1 (threads: 2, active: 2, queued: 0)
13:01:02.48 : job no. 7 was rejected by the pool
13:01:02.50 : thread Main handed the jobs to the pool and waits for their end
13:01:02.48 : job no. 6 starts in thread pool-1-thread-5 (threads: 5, active: 5, queued: 2)
13:01:05.49 : job no. 5 ends: scheduled for 3 s, it lasted 3.01 s since it was requested
13:01:05.51 : job no. 3 starts in thread pool-1-thread-4 (threads: 5, active: 5, queued: 1)
13:01:05.50 : job no. 6 ends: scheduled for 3 s, it lasted 3.03 s since it was requested
13:01:05.51 : job no. 4 starts in thread pool-1-thread-5 (threads: 5, active: 5, queued: 0)
13:01:05.49 : job no. 1 ends: scheduled for 3 s, it lasted 3.02 s since it was requested
13:01:05.50 : job no. 0 ends: scheduled for 3 s, it lasted 3.03 s since it was requested
13:01:05.49 : job no. 2 ends: scheduled for 3 s, it lasted 3.01 s since it was requested
13:01:08.51 : job no. 3 ends: scheduled for 3 s, it lasted 6.03 s since it was requested
13:01:08.51 : job no. 4 ends: scheduled for 3 s, it lasted 6.03 s since it was requested
13:01:08.51 : end of thread Main
  • Os jobs 0, 1 e 2 foram atribuídos às três threads permanentes criadas para esse fim;
  • os jobs 3 e 4 foram colocados na fila, que agora está cheia;
  • Os jobs 5 e 6 provocaram a criação de duas threads adicionais ([pool-1-thread-4] e [pool-1-thread-5]): elas começaram imediatamente, antes dos jobs 3 e 4, que esperavam na fila. Essa é a regra do [ThreadPoolExecutor]: primeiro a fila, depois as threads adicionais — o que costuma surpreender;
  • O job 7 foi rejeitado: 5 threads ocupadas, fila cheia;
  • Os jobs 3 e 4 tiveram de esperar que uma thread ficasse disponível depois que os primeiros jobs terminaram: aqui, eles reutilizaram as threads 4 e 5 — as duas threads adicionais que foram liberadas primeiro. No total, levaram pouco mais de 6 segundos a partir do momento da solicitação: 3 segundos de espera e 3 segundos de processamento;
  • os valores exibidos por cada job ao iniciar (número de threads, fila) dependem do momento exato em que ele obteve o processador: eles variam de uma execução para outra, assim como as threads reutilizadas pelos jobs 3 e 4. No entanto, o desfecho de cada job (execução imediata, espera na fila ou rejeição) é reproduzível.

Raramente se constrói um *[ThreadPoolExecutor] diretamente: a classe *[Executors] fornece métodos de construção para os casos comuns:

Método
Executor retornado
[newFixedThreadPool(n)]
um pool de n threads permanentes, com uma fila de capacidade ilimitada
[newCachedThreadPool()]
um pool sem threads permanentes, que cria quantas threads forem necessárias e destrói as que permanecem inativas por 60 segundos
[newSingleThreadExecutor()]
uma única thread que executa as tarefas uma após a outra, na ordem em que foram submetidas
[newScheduledThreadPool(n)]
um pool capaz de executar tarefas após um atraso ou periodicamente (interface [ScheduledExecutorService])
[newVirtualThreadPerTaskExecutor()]
(Java 21) um executor sem pool, que cria uma nova thread virtual para cada tarefa

O último executor merece uma observação: as threads virtuais não são colocadas em um pool. Elas são tão baratas que uma nova é criada para cada tarefa; para limitar o uso de recursos, usa-se um semáforo, como no programa [Threads15.kt]. Vale notar também que a biblioteca de corrotinas pode transformar um executor em um “dispatcher” ([executor.asCoroutineDispatcher()]): as corrotinas do Capítulo 9 também acabam sendo executadas em pools de threads.

8.10.2. Tarefas com resultado: Callable e Future

O método [execute] passa um [Runnable] ao pool, que não retorna resultado. O método [submit(task)] também aceita um [Callable<V>], uma interface funcional cujo método [call(): V] retorna um resultado do tipo V (em Java, ele declara [throws Exception]; o Kotlin ignora essa declaração). Ele retorna um objeto [Future<V>] que permite acompanhar a tarefa:

Método de Future<V>
Função
[get(): V], [get(timeout: Long, unit: TimeUnit): V]
espera a tarefa terminar (por no máximo [timeout]) e retorna seu resultado. Se a tarefa lançar uma exceção, [get] lança uma [ExecutionException] que a encapsula (propriedade [cause])
[isDone(): Boolean]
indica se a tarefa terminou (normalmente, por causa de uma exceção ou por cancelamento); em Kotlin, é a propriedade [isDone]
[state(): Future.State]
(Java 19) o estado da tarefa: [RUNNING], [SUCCESS], [FAILED], ou [CANCELLED]
[resultNow(): V], [exceptionNow(): Throwable]
(Java 19) o resultado ou a exceção de uma tarefa que já terminou, sem esperar
[cancel(mayInterruptIfRunning: Boolean): Boolean]
cancela a tarefa; se ela já foi iniciada e [mayInterruptIfRunning] for igual a [true], a thread que a executa é interrompida

O método [invokeAll(collection of Callable)] do executor submete todas as tarefas de uma coleção, espera que todas terminem e retorna a lista de seus valores [Future], na ordem da coleção. O método [invokeAny] retorna o resultado da primeira tarefa concluída com sucesso e cancela as demais. O programa [Threads26.kt] é o seguinte:

// ExecutorService: submissão de tarefas e obtenção de seu resultado com Future
package threads26

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.Callable
import java.util.concurrent.ExecutionException
import java.util.concurrent.Executors
import java.util.concurrent.Future

fun main() {
    println("Main thread: ${Thread.currentThread()}")

    // 1 - um pool de 2 threads, fechado automaticamente ao fim do bloco use
    Executors.newFixedThreadPool(2).use { pool ->
        // três tarefas que devolvem cada uma um resultado do tipo Int
        val futures: List<Future<Int>> = List(3) { number ->
            pool.submit<Int> {
                val name = Thread.currentThread().name
                println("${time()} : task $number runs in thread $name")
                // trabalho
                Thread.sleep(500L * (number + 1))
                // o resultado da tarefa
                number * 10
            }
        }
        // os resultados: get() espera o fim da tarefa
        futures.forEachIndexed { i, future ->
            try {
                println("task $i: result ${future.get()}, state ${future.state()}")
            } catch (e: ExecutionException) {
                println("task $i in error: ${e.cause}")
            }
        }

        // uma tarefa que lança uma exceção
        val failed = pool.submit<Int> { fail() }
        try {
            failed.get()
        } catch (e: ExecutionException) {
            // a exceção da tarefa é encapsulada em uma ExecutionException
            val cause = e.cause!!
            println("${e::class.simpleName} containing ${cause::class.simpleName} : ${cause.message}")
        }
        println("task in error: state ${failed.state()}")
    }

    // 2 - uma thread virtual por tarefa; invokeAll submete uma coleção de tarefas e espera o fim delas
    Executors.newVirtualThreadPerTaskExecutor().use { executor ->
        val jobs = List(3) { number ->
            Callable {
                Thread.sleep(300)
                "job $number executed by ${Thread.currentThread()}"
            }
        }
        for (future in executor.invokeAll(jobs)) {
            // a tarefa terminou: resultNow() devolve seu resultado sem esperar
            println(future.resultNow())
        }
    }
}

// o trabalho da tarefa que falha
fun fail(): Int = throw IllegalStateException("test....")

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linha 15: um pool de 2 threads, criado por [Executors.newFixedThreadPool(2)] e fechado ao final do bloco [use];
  • linhas 17–24: cada tarefa é uma lambda que exibe a thread que a executa, dorme por 0,5, 1 ou 1,5 segundo e depois retorna um resultado inteiro — o valor de sua última expressão. A função [List] constrói a lista dos três objetos [Future<Int>] retornados por [submit];
  • linha 18: cuidado com a sobrecarga de submit. O método *[submit] existe em várias versões, incluindo ***[submit(Runnable)] e ***[submit(Callable<T>)]***. Com uma lambda, o Java escolhe a versão [Callable] se a lambda retornar um valor. O Kotlin, por outro lado, trata qualquer lambda como conversível em [Runnable]* (caso em que seu valor é ignorado) e escolhe [submit(Runnable)]! Se você escrever ***[val f = pool.submit { 10 }], o compilador simplesmente emite um aviso:
warning: expression is unused.

e [f.get()] produz [null], o “resultado” de um [Runnable]. Impomos a versão [Callable] especificando o argumento de tipo, [submit<Int> { … }], como mostrado aqui, ou criando explicitamente um [Callable]: [pool.submit(Callable { … })]. O [Thread.sleep] da linha 22 não precisa ser envolvido por um [try]: o Kotlin não tem exceções verificadas, e qualquer [InterruptedException] eventual seria registrada no [Future];

  • linha 28: a função [forEachIndexed] percorre a lista, fornecendo o índice e o elemento;
  • linha 30: [future.get()] espera a tarefa terminar e retorna seu resultado; [future.state()] retorna seu estado. Como [state] não é um acessor do tipo [getXxx], o Kotlin o trata como método, e não como propriedade;
  • linha 37: uma tarefa que executa a função [fail] (linha 64), que lança uma exceção. O tipo de retorno de [fail] é [Int]: a expressão [throw …] é do tipo [Nothing], que é compatível com todos os tipos;
  • linhas 39–43: a exceção lançada na tarefa não se perde; ela é armazenada no objeto [Future] e depois relançada na thread que solicita o resultado, encapsulada em uma *[ExecutionException] cuja propriedade [cause]* (o método Java *[getCause]*) contém a exceção original. Essa propriedade é do tipo [Throwable?]; o operador [!!] afirma que ela não é [null], o que aqui é garantido. A expressão [e::class.simpleName] fornece o nome curto da classe da exceção;
  • linhas 49–58: um executor que cria uma thread virtual por tarefa. As tarefas são criadas explicitamente como [Callable], usando o construtor SAM [Callable { … }] (linha 51): a lista [jobs] é, portanto, do tipo [List<Callable<String>>]. O método [invokeAll] (linha 56) atribui os três jobs ao executor e espera que terminem. Uma vez concluídas as tarefas, [resultNow] retorna seus resultados imediatamente.

Resultados:

> gradlew -q run -Pmain=threads26.Threads26Kt
Main thread: Thread[#3,main,5,main]
13:01:08.772 : task 0 runs in thread pool-1-thread-1
13:01:08.769 : task 1 runs in thread pool-1-thread-2
13:01:09.291 : task 2 runs in thread pool-1-thread-1
task 0: result 0, state SUCCESS
task 1: result 10, state SUCCESS
task 2: result 20, state SUCCESS
ExecutionException containing IllegalStateException : test....
task in error: state FAILED
job 0 executed by VirtualThread[#24]/runnable@ForkJoinPool-1-worker-1
job 1 executed by VirtualThread[#27]/runnable@ForkJoinPool-1-worker-2
job 2 executed by VirtualThread[#29]/runnable@ForkJoinPool-1-worker-2
  • as tarefas são executadas nas threads do pool ([pool-1-thread-1] e [pool-1-thread-2]);
  • a tarefa 2 só começou depois que a tarefa 0 terminou, na thread que a tarefa 0 liberou: o pool tem apenas 2 threads, e a tarefa 2 esperou na fila. Esse comportamento é reproduzível;
  • os resultados são recuperados depois que as tarefas terminaram, e seu estado é [SUCCESS];
  • a exceção da tarefa que falhou foi capturada pela thread principal, e o estado da tarefa é [FAILED];
  • os três jobs da segunda parte foram executados por três threads virtuais diferentes, montadas nas threads transportadoras [ForkJoinPool-1-worker-1] e [ForkJoinPool-1-worker-2] (a distribuição entre as transportadoras varia de uma execução para outra).

Bloquear uma thread em [get] para esperar um resultado é simples, mas não é possível encadear operações de processamento à conclusão de uma tarefa sem esperar. O capítulo seguinte apresenta a classe [CompletableFuture] do JDK, que permite isso e, principalmente, a solução do Kotlin: as corrotinas, com [async] e [Deferred] (o equivalente de um [Future] cujo resultado é aguardado por [await] sem bloquear uma thread). Por fim, observe que o Java 25 oferece, como preview, a concorrência estruturada ([StructuredTaskScope]), que trata um grupo de subtarefas como uma única unidade de trabalho (se uma falha, as outras são canceladas). Ela não é usada neste curso: as corrotinas do Kotlin se baseiam nesse mesmo princípio, que há muito tempo é um recurso padrão do Kotlin, e o Capítulo 9 se concentra extensamente nelas.

8.11. Paralelismo de dados

8.11.1. Streams paralelos

Voltemos ao uso principal das threads: aproveitar todos os processadores em um cálculo demorado. A biblioteca padrão do Kotlin não fornece operações paralelas sobre coleções: suas funções ([filter], [map], [count]…) e suas sequências são sequenciais. No entanto, um programa Kotlin tem acesso à API Stream do Java (Capítulo 5), cujos streams podem ser executados em paralelo: basta chamar [parallel()] em um stream, ou [parallelStream()] em vez de [stream()] em uma coleção (uma lista Kotlin é uma [java.util.List]: ela tem esses métodos). O stream então divide os dados em blocos, faz os blocos serem processados por várias threads e depois combina os resultados parciais. As threads utilizadas são as do pool compartilhado ([ForkJoinPool.commonPool()]), às quais se junta a thread que executa o stream. Por padrão, o pool compartilhado tem tantas threads quanto processadores, menos uma: a thread chamadora faz a contagem.

Esses fluxos só são adequados se o processamento de cada elemento for independente dos demais: a ordem de processamento é indefinida e, se o processamento atualizar dados compartilhados, estes devem ser protegidos. O programa [Threads27.kt] é o seguinte:

// streams paralelos: IntStream.parallel e parallelStream
package threads27

import java.time.LocalTime
import java.time.format.DateTimeFormatter
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ForkJoinPool
import java.util.stream.IntStream
import kotlin.time.measureTimedValue

fun main() {
    // 1 - contagem dos números primos menores que N
    val N = 5_000_000
    // versão sequencial: um loop for
    val (nbLoop, durationLoop) = measureTimedValue {
        var nb = 0
        for (i in 2..<N) {
            if (isPrime(i)) nb++
        }
        nb
    }
    display("sequential for", nbLoop.toLong(), durationLoop.inWholeMilliseconds)

    // versão sequencial: a função count do Kotlin sobre um intervalo
    val (nbKotlin, durationKotlin) = measureTimedValue { (2..<N).count { isPrime(it) } }
    display("sequential count", nbKotlin.toLong(), durationKotlin.inWholeMilliseconds)

    // versão sequencial: um stream Java
    val (nbStream, durationStream) = measureTimedValue { IntStream.range(2, N).filter { isPrime(it) }.count() }
    display("sequential stream", nbStream, durationStream.inWholeMilliseconds)

    // versão paralela: o mesmo stream, tornado paralelo
    val (nbParallel, durationParallel) = measureTimedValue {
        IntStream.range(2, N).parallel().filter { isPrime(it) }.count()
    }
    display("parallel stream", nbParallel, durationParallel.inWholeMilliseconds)

    // as threads que trabalharam e o número de números primos encontrados por cada uma
    val threads = ConcurrentHashMap<String, Int>()
    IntStream.range(2, N).parallel()
        .filter { isPrime(it) }
        .forEach { threads.merge(Thread.currentThread().name, 1, Int::plus) }
    for ((name, nb) in threads.toSortedMap()) {
        println("  thread %-30s : %,d prime numbers found".format(name, nb))
    }

    // 2 - processamento de uma coleção em paralelo
    val files = listOf("a.txt", "b.txt", "c.txt", "d.txt", "e.txt")
    files.parallelStream().forEach { file ->
        println("${time()} : processing of $file in thread ${Thread.currentThread().name}")
        // processamento simulado
        sleep(500)
    }
    println("parallel forEach finished")
    println("Parallelism of the common pool: ${ForkJoinPool.getCommonPoolParallelism()}")
}

// exibição de um resultado e de sua duração
fun display(method: String, nb: Long, ms: Long) {
    println("%-20s : %,d prime numbers in %d ms".format(method, nb, ms))
}

// teste de primalidade (deliberadamente simples)
fun isPrime(n: Int): Boolean {
    if (n < 2) return false
    var d = 2
    while (d * d <= n) {
        if (n % d == 0) return false
        d++
    }
    return true
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// a hora atual, em milissegundos
fun time(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS"))

Comentários:

  • linhas 15–22: os números primos menores que 5.000.000 são contados com um laço [for] comum. A função [isPrime] (linhas 64–71) testa os divisores até a raiz quadrada do número: é um processamento demorado, e as iterações são independentes. A duração é medida pela função [measureTimedValue] da biblioteca padrão ([kotlin.time]): ela executa sua lambda e retorna um objeto [TimedValue] que contém o valor retornado pela lambda e a duração de sua execução (uma *[Duration]*); esse objeto é desestruturado em duas variáveis. A propriedade *[inWholeMilliseconds] fornece a duração em milissegundos. O Java media as durações usando ***[System.nanoTime()]**;
  • linha 25: o mesmo cálculo, escrito no estilo Kotlin: a função [count] do intervalo [2..<N] conta os elementos que satisfazem o predicado. Isso é sequencial;
  • linha 29: o mesmo cálculo usando um stream Java sequencial: [IntStream.range(2, N)] gera os inteiros de 2 a N - 1, [filter] mantém apenas os números primos e [count] os conta (o resultado é um [Long]). A lambda [{ isPrime(it) }] é convertida em [IntPredicate], a interface funcional esperada por [filter];
  • linhas 33–34: o mesmo fluxo, tornado paralelo por [parallel()]. Nada mais precisa ser alterado: cada thread conta os números primos de seus segmentos, e o fluxo soma as contagens parciais. Nenhum dado é compartilhado entre as threads;
  • linhas 39–44: para determinar quais threads concluíram seu trabalho, o stream paralelo conta, para cada thread, os números primos que ela encontrou e os armazena em um [ConcurrentHashMap] compartilhado. Trata-se de um dado compartilhado, atualizado por uma operação atômica ([merge]);
  • linhas 48–52: o método [parallelStream()] de uma lista Kotlin de nomes de arquivos retorna um stream paralelo; [forEach] processa cada arquivo (o processamento é simulado por uma pausa de meio segundo). Com um stream paralelo, [forEach] não preserva a ordem da lista; [forEachOrdered] a preservaria, ao custo de parte do paralelismo;
  • linha 55: o número de threads do pool compartilhado;
  • linhas 59–60: exibição de um resultado: [%-20s] alinha o nome do método à esquerda em 20 caracteres.

Resultados:

> gradlew -q run -Pmain=threads27.Threads27Kt
sequential for       : 348,513 prime numbers in 2523 ms
sequential count     : 348,513 prime numbers in 1891 ms
sequential stream    : 348,513 prime numbers in 3697 ms
parallel stream      : 348,513 prime numbers in 4583 ms
  thread ForkJoinPool.commonPool-worker-1 : 224,082 prime numbers found
  thread main                           : 124,431 prime numbers found
12:56:50.425 : processing of b.txt in thread ForkJoinPool.commonPool-worker-1
12:56:50.440 : processing of c.txt in thread main
12:56:50.943 : processing of e.txt in thread main
12:56:50.955 : processing of a.txt in thread ForkJoinPool.commonPool-worker-1
12:56:51.451 : processing of d.txt in thread main
parallel forEach finished
Parallelism of the common pool: 1
  • As quatro versões encontram o mesmo número de números primos;
  • duas threads participaram do processamento paralelo: a thread [main] e a única thread do pool compartilhado ([ForkJoinPool.commonPool-worker-1]): nesta máquina de dois processadores, o pool compartilhado tem apenas uma thread (última linha);
  • os arquivos são processados em pares, com meio segundo de intervalo, e em uma ordem que não corresponde à da lista;
  • aqui, o fluxo paralelo não foi mais rápido que as versões sequenciais e foi, na verdade, o mais lento. Isso não é uma falha do processamento paralelo: no momento do teste, a máquina (2 processadores) executava muitos outros programas muito ativos (uma carga média de cerca de dez threads prontas para execução para 2 processadores), de modo que o segundo processador, no qual o processamento paralelo contava, não estava disponível. Os tempos de execução medidos também variaram bastante de uma execução para outra em todas as versões. Em uma máquina pouco carregada com n processadores, um processamento paralelo como este pode ser quase n vezes mais rápido que o sequencial. É sempre necessário medir o desempenho em condições reais antes de tirar conclusões: a paralelização tem um custo (particionamento do trabalho, sincronização, combinação dos resultados) que só compensa se o processamento de cada elemento exigir cálculo suficiente e se houver processadores disponíveis para executá-lo.

No próximo capítulo, também paralelizaremos cálculos usando corrotinas, iniciando-as no dispatcher [Dispatchers.Default], cujas threads também são tão numerosas quanto os processadores.

8.11.2. Dividir para conquistar: ForkJoinPool e RecursiveTask

Os streams paralelos se baseiam no framework Fork/Join (Java 7), que também pode ser usado diretamente. Ele é adequado para algoritmos de “dividir para conquistar”: uma tarefa grande demais é decomposta em subtarefas, que por sua vez são decompostas, até que as partes sejam pequenas o bastante para serem processadas diretamente; os resultados das subtarefas são então combinados. Uma tarefa é uma classe derivada de [RecursiveTask<V>] (uma tarefa que retorna um resultado do tipo V) ou de [RecursiveAction] (sem resultado), na qual o método [compute] é sobrescrito. Em [compute], o método [fork()] de uma subtarefa a submete imediatamente ao pool, e seu método [join()] espera pelo resultado.

As tarefas são executadas por um [ForkJoinPool], no qual cada thread tem sua própria fila de tarefas. Uma thread que não tem mais nada a fazer “rouba” tarefas da fila de outra thread (“work stealing”): a carga é assim distribuída automaticamente. As threads que transportam as threads virtuais também formam um [ForkJoinPool]: é o que vimos na representação textual das threads virtuais ([ForkJoinPool-1-worker-1]). O programa [Threads28.kt] conta números primos usando uma tarefa recursiva:

// dividir para conquistar: ForkJoinPool e RecursiveTask
package threads28

import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ForkJoinPool
import java.util.concurrent.RecursiveTask
import kotlin.time.measureTimedValue

fun main() {
    val N = 5_000_000
    // o pool comum, usado por padrão pelos streams paralelos
    val (nb, duration) = measureTimedValue { ForkJoinPool.commonPool().invoke(CountPrimes(2, N)) }
    println("common pool       : %,d prime numbers in %d ms".format(nb, duration.inWholeMilliseconds))

    // um pool de 4 threads, fechado ao fim do bloco use
    ForkJoinPool(4).use { pool ->
        CountPrimes.chunks.clear()
        val (nb4, duration4) = measureTimedValue { pool.invoke(CountPrimes(2, N)) }
        println("pool of 4 threads : %,d prime numbers in %d ms".format(nb4, duration4.inWholeMilliseconds))
        println("tasks stolen by one thread from another: ${pool.stealCount}")
    }
    // a distribuição dos blocos entre as threads do último pool
    for ((name, nbChunks) in CountPrimes.chunks.toSortedMap()) {
        println("  %-25s : %d chunks processed".format(name, nbChunks))
    }
}

// uma tarefa que conta os números primos do intervalo [start, end[
class CountPrimes(private val start: Int, private val end: Int) : RecursiveTask<Int>() {
    companion object {
        // abaixo deste limite, o bloco é processado diretamente
        const val THRESHOLD = 100_000
        // o número de blocos processados por cada thread
        val chunks = ConcurrentHashMap<String, Int>()
    }

    override fun compute(): Int {
        // bloco pequeno o bastante: é processado sequencialmente
        if (end - start <= THRESHOLD) {
            chunks.merge(Thread.currentThread().name, 1, Int::plus)
            return (start..<end).count { isPrime(it) }
        }
        // caso contrário, é dividido em dois
        val middle = (start + end) ushr 1
        val left = CountPrimes(start, middle)
        val right = CountPrimes(middle, end)
        // a metade esquerda é entregue ao pool (outra thread pode "roubá-la")
        left.fork()
        // a metade direita é processada pela thread atual
        val nbRight = right.compute()
        // esperamos o resultado da metade esquerda e combinamos os dois resultados
        return left.join() + nbRight
    }
}

// teste de primalidade (deliberadamente simples)
fun isPrime(n: Int): Boolean {
    if (n < 2) return false
    var d = 2
    while (d * d <= n) {
        if (n % d == 0) return false
        d++
    }
    return true
}

Comentários:

  • linhas 29–52: a tarefa [CountPrimes] conta números primos no intervalo [start, end[. Ela deriva de [RecursiveTask<Int>]: a classe Java é abstrata; seu construtor sem parâmetros ([RecursiveTask<Int>()]) é chamado no cabeçalho da classe. Os limites [start] e [end] são propriedades privadas declaradas no construtor primário;
  • linhas 30–34: os membros da classe são agrupados no companion object: o limiar [THRESHOLD] (abaixo de 100.000 números, um intervalo é processado diretamente) e, para cada thread, o número de blocos que ela processou ([chunks]). As tarefas Fork/Join são serializáveis; o Java declarava um número de versão de serialização ([serialVersionUID]), exigido por sua opção de compilação [-Xlint:all]. O compilador Kotlin não o exige, e nunca serializaremos essas tarefas: nós o omitimos;
  • linha 37: a redefinição do método [compute], declarado como [protected] em Java: a redefinição continua [protected] sem que precisemos especificá-lo;
  • linhas 39–41: um bloco relativamente pequeno é processado sequencialmente pela função [count] do intervalo;
  • linhas 44–46: um bloco grande demais é dividido em duas subtarefas. A expressão [(start + end) ushr 1] calcula o ponto médio usando um deslocamento à direita sem sinal (a função infixa [ushr], que corresponde ao operador Java [>>>]), o que evita um overflow se a soma exceder a capacidade de um [Int];
  • linha 48: a metade esquerda é colocada no pool: outra thread pode pegá-la;
  • linha 50: a metade direita é processada pela thread atual por meio de uma chamada direta a [compute]. Não há necessidade de atribuir as duas metades ao pool: a thread atual não teria nada a fazer além de esperar;
  • linha 52: a thread espera o resultado da metade esquerda (que ela mesma processará se ninguém a tiver “roubado”) e combina os dois resultados;
  • linha 12: a tarefa é executada primeiro pelo pool compartilhado. O método [invoke(task)] submete a tarefa e espera seu resultado;
  • linhas 16–20: depois, por um pool de 4 threads, usado em um bloco [use] ([ForkJoinPool] é um [ExecutorService]). A propriedade [stealCount] (método Java [getStealCount]) retorna o número de tarefas roubadas por uma thread de outra;
  • linhas 23–24: a distribuição dos blocos entre as threads desse pool.

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=threads28.Threads28Kt
common pool       : 348,513 prime numbers in 3638 ms
pool of 4 threads : 348,513 prime numbers in 2568 ms
tasks stolen by one thread from another: 6
  ForkJoinPool-1-worker-1   : 13 chunks processed
  ForkJoinPool-1-worker-2   : 16 chunks processed
  ForkJoinPool-1-worker-3   : 14 chunks processed
  ForkJoinPool-1-worker-4   : 21 chunks processed
  • o pool compartilhado não foi mais rápido que um laço sequencial (compare com o programa anterior): nesta máquina, ele tem apenas uma thread, e a thread principal — que espera o resultado em [invoke] — não participa do cálculo como ocorre em um fluxo paralelo;
  • o pool de 4 threads foi mais rápido porque conseguiu usar os dois processadores, mas não duas vezes mais rápido, já que a máquina continuava muito carregada por outros programas. Ter mais threads do que processadores não traz benefício em um cálculo puro, mas aqui também não custa muito;
  • os 64 blocos (5.000.000 / 100.000, arredondado para a próxima potência de 2 devido às divisões ao meio) foram distribuídos entre as 4 threads por meio do roubo de tarefas. Essa distribuição, assim como os tempos de execução, varia de uma execução para outra; o número de blocos e o resultado do cálculo são reproduzíveis.

Os streams paralelos bastam na maioria dos casos; uma tarefa Fork/Join só é escrita para um algoritmo recursivo que não pode ser facilmente expresso como um stream (ordenação, percurso de árvores etc.).

8.12. Dados locais à thread

8.12.1. O princípio

Considere uma aplicação em três camadas:

Image

Suponha que a aplicação seja multiusuário, como uma aplicação web. Cada requisição de usuário é tratada por uma thread. O ciclo de vida da thread é o seguinte:

  • a thread é criada (thread virtual) ou solicitada a um pool de threads para atender à requisição de um usuário;
  • se essa requisição precisa de dados, a thread executa uma função na camada [ui], que chama uma função na camada [business], que por sua vez chama uma função na camada [dao];
  • a thread devolve a resposta ao usuário. Depois, ela termina ou é devolvida ao pool de threads.

Durante a segunda etapa, pode ser útil que a thread tenha dados próprios — isto é, dados não compartilhados com outras threads. Esses dados poderiam, por exemplo, pertencer ao usuário específico que a thread está atendendo e ser usados nas diversas camadas [ui, business, dao] sem serem passados como parâmetro a cada função.

O JDK fornece duas ferramentas para esse fim, que o Kotlin utiliza tal como estão:

  • a classe [ThreadLocal<T>] (Java 1.2): um objeto cujo valor — lido por [get()] e escrito por [set(value)] — é diferente para cada thread. O construtor [ThreadLocal.withInitial(factory)] fornece o valor inicial para cada thread; o método [remove()] apaga o valor da thread atual. A classe derivada [InheritableThreadLocal<T>] passa o valor da thread criadora para a thread recém-criada;
  • a classe [ScopedValue<T>] (final no Java 25): um valor vinculado a uma thread por um escopo limitado do código, que não pode ser modificado dentro desse escopo.

8.12.2. A classe ThreadLocal

O programa [Threads29.kt] compara uma propriedade comum, um [ThreadLocal], e um [InheritableThreadLocal]:

// dados locais à thread: ThreadLocal e InheritableThreadLocal
package threads29

import kotlin.concurrent.thread

// os dados do programa
object Context {
    // uma propriedade comum (volatile): uma única cópia, compartilhada por todas as threads
    @Volatile
    var shared = 0
    // uma cópia por thread; valor inicial null
    val perThread = ThreadLocal<Int?>()
    // uma cópia por thread, inicializada para cada thread pela fábrica fornecida
    val user: ThreadLocal<String> =
        ThreadLocal.withInitial { "anonymous (thread ${Thread.currentThread().name})" }
    // uma cópia por thread, cujo valor inicial é herdado da thread criadora
    val language = InheritableThreadLocal<String?>()
}

fun main() {
    Thread.currentThread().name = "Main"
    // a thread principal escreve seus próprios valores
    Context.shared = 100
    Context.perThread.set(100)
    Context.user.set("admin")
    Context.language.set("fr")

    // três threads escrevem e depois leem os dados novamente
    val threads = List(3) { number ->
        thread(name = "T$number") {
            // escrita
            Context.shared = number
            Context.perThread.set(number)
            // a thread T2 não define um usuário: ela terá o valor inicial
            if (number != 2) {
                Context.user.set("user$number")
            }
            // a thread T1 altera o idioma herdado da thread principal
            if (number == 1) {
                Context.language.set("en")
            }
            // as outras threads têm permissão para escrever por sua vez
            sleep(200)
            // nova leitura
            display()
        }
    }
    threads.forEach { it.join() }
    // nova leitura pela thread principal
    display()
}

// exibe os dados vistos pela thread atual
fun display() {
    println("%-4s : shared=%-3d perThread=%-3d user=%-20s language=%s".format(
        Thread.currentThread().name, Context.shared, Context.perThread.get(),
        Context.user.get(), Context.language.get()))
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

Comentários:

  • linhas 9–10: uma propriedade comum do objeto [Context]. Há apenas uma instância dela, compartilhada por todas as threads. Ela é [@Volatile], para que cada thread veja o último valor escrito pelas outras;
  • linha 12: um objeto [ThreadLocal<Int?>]. Cada thread tem seu próprio valor; enquanto uma thread não escreve nele, [get] retorna [null]. Declaramos o tipo [Int?] dos valores para que o compilador saiba que [get] pode produzir [null]: com [ThreadLocal<Int>], o Kotlin trataria o resultado de *[get]* como um tipo de plataforma (***[Int!]***), sobre o qual não faz nenhuma verificação;
  • linhas 14–15: um objeto [ThreadLocal<String>] criado por [ThreadLocal.withInitial { … }]. A lambda passada a esse método (convertida em [Supplier]) é executada na primeira vez que uma thread lê o valor sem tê-lo escrito; ela fornece o valor inicial para essa thread. Aqui, [get] nunca retorna [null]: o tipo [String] se justifica. O Kotlin também fornece uma função de extensão, [getOrSet { … }] (pacote [kotlin.concurrent]), que retorna o valor da thread atual depois de inicializá-lo com a lambda caso ele seja [null];
  • linha 17: um objeto [InheritableThreadLocal<String?>]: quando uma thread é criada, seu valor inicial é uma cópia do valor que a thread criadora tinha naquele momento;
  • linhas 23–26: a thread principal escreve seus próprios valores;
  • linhas 32–40: cada thread escreve seus próprios valores, exceto a thread T2, que não define um usuário, e a thread T1, que é a única a alterar o idioma;
  • linha 43: cada thread espera que as outras escrevam antes de ler os valores novamente;
  • linhas 54–57: os dados exibidos como vistos pela thread atual. O formato [%-3d] aceita um valor [null], que ele exibe como [null].

Resultados:

1
2
3
4
5
> gradlew -q run -Pmain=threads29.Threads29Kt
T0   : shared=1   perThread=0   user=user0                language=fr
T2   : shared=1   perThread=2   user=anonymous (thread T2) language=fr
T1   : shared=1   perThread=1   user=user1                language=en
Main : shared=1   perThread=100 user=admin                language=fr
  • a propriedade comum [shared] tem o mesmo valor para todas as threads: o último valor escrito (nesta execução, o da thread T1; outra execução pode produzir um valor diferente);
  • [perThread] manteve, em cada thread, o valor que essa thread nele havia escrito;
  • [user] tem o valor escrito por cada thread; a thread T2, que não havia escrito nele, obteve o valor inicial fornecido pela lambda de [withInitial];
  • [language] é igual a [fr] nas threads T0 e T2, que o herdaram da thread principal sem nunca escrever nele. A thread T1 o alterou para [en] somente para si: a thread principal e as outras threads não veem essa alteração;
  • exceto pelo valor de [shared] e pela ordem das três primeiras linhas, esses resultados são reproduzíveis.

Um [ThreadLocal] exige algumas precauções. O valor de uma thread existe apenas enquanto a própria thread existir: com um pool de threads, a thread que atende uma requisição atenderá depois outras requisições, e é preciso chamar [remove] ao final de cada requisição; caso contrário, a requisição seguinte encontraria os dados da anterior (e a memória nunca seria liberada). Com threads virtuais, é possível criar milhões de threads, cada uma com sua própria cópia dos dados: [InheritableThreadLocal] copia então seus valores para cada uma delas. Por fim, um valor que pode ser modificado por qualquer função dentro da thread torna o código difícil de acompanhar. A classe [ScopedValue] evita esses problemas.

As corrotinas do Capítulo 9 apresentam um problema particular: uma corrotina pode começar a execução em uma thread e continuar em outra, e um *[ThreadLocal] não a acompanharia. Para resolver isso, a biblioteca de corrotinas fornece a função de extensão [asContextElement(value)] de [ThreadLocal], que define o valor de [ThreadLocal] em cada thread em que a corrotina é executada; as corrotinas também têm seu próprio mecanismo de dados de contexto, o contexto da corrotina*. Trataremos disso no próximo capítulo.

8.12.3. A classe ScopedValue

Um valor [ScopedValue<T>] é vinculado a um valor durante a execução de um trecho de código, chamado de seu escopo:

  • [ScopedValue.newInstance()] cria um valor vinculado, normalmente armazenado em uma propriedade de nível superior ou na propriedade de um objeto, que é somente leitura ([val]);
  • [ScopedValue.where(sv, value).run(action)] executa a ação (um [Runnable]) vinculando [sv] a [value]. Enquanto a ação — e todas as funções que ela chama — está sendo executada na thread atual, [sv.get()] retorna [value]. Quando a ação termina, a vinculação desaparece: não há nada a limpar;
  • [ScopedValue.where(sv, value).call(op)] faz o mesmo com uma operação que retorna um resultado;
  • dentro do escopo, o valor não pode ser modificado; ele só pode ser vinculado a outro valor em um escopo aninhado;
  • [isBound()] indica se o valor está vinculado na thread atual (o Kotlin trata isso como uma propriedade [isBound]); [orElse(other)] retorna o valor vinculado ou, se não houver, [other]. Fora de qualquer escopo, [get()] lança a exceção [NoSuchElementException].

A classe [ScopedValue] é final desde o Java 25: um programa Kotlin compilado para o Java 25 a utiliza sem nenhuma opção especial nem avisos. O programa é o seguinte:

// valores vinculados a um escopo: ScopedValue (Java 25)
package threads30

// o usuário em nome de quem o código é executado
val USER: ScopedValue<String> = ScopedValue.newInstance()

fun main() {
    println("Outside any scope, is USER bound? ${USER.isBound}")
    try {
        USER.get()
    } catch (e: NoSuchElementException) {
        println("get() out of scope: ${e::class.simpleName}")
    }

    // 1 - dois processamentos simultâneos, cada um para seu próprio usuário
    val t1 = Thread.ofVirtual().start { ScopedValue.where(USER, "alice").run(::process) }
    val t2 = Thread.ofVirtual().start { ScopedValue.where(USER, "bob").run(::process) }
    t1.join()
    t2.join()

    // 2 - um escopo pode conter outro, que vincula temporariamente outro valor
    ScopedValue.where(USER, "admin").run {
        display("outer scope")
        ScopedValue.where(USER, "guest").run { display("inner scope") }
        display("back in the outer scope")
        // uma thread criada no escopo não herda o vínculo
        val child = Thread.ofVirtual().start { println("child thread: bound? ${USER.isBound}") }
        child.join()
    }

    // 3 - call: um processamento vinculado que devolve um resultado
    val message = ScopedValue.where(USER, "carole")
        .call<String, RuntimeException> { "hello ${USER.get()}" }
    println(message)
    // após o escopo, o vínculo desapareceu
    println("After the scopes: bound? ${USER.isBound}, orElse: ${USER.orElse("nobody")}")
}

// a camada [business] chama a camada [dao] sem lhe passar o usuário
fun process() {
    display("[business] layer")
    dao()
}

// a camada [dao] encontra o usuário no escopo atual
fun dao() {
    display("[dao] layer")
}

// exibe o usuário vinculado no escopo atual
fun display(place: String) {
    println("$place : USER = ${USER.get()}")
}

Comentários:

  • linha 5: o valor vinculado [USER], uma propriedade de nível superior somente leitura. Seu tipo, [ScopedValue<String>], é declarado explicitamente: o método genérico [newInstance] não consegue inferi-lo;
  • Linhas 8–12: fora de qualquer escopo, o valor não está vinculado e [get] lança uma exceção. A classe [NoSuchElementException] não precisa ser importada: o Kotlin a trata como um apelido de tipo (type alias) da biblioteca padrão ([kotlin.NoSuchElementException]);
  • Linhas 16–17: duas threads virtuais executam a função [process], cada uma em um escopo no qual [USER] está vinculado a um usuário diferente. A referência de função [::process] é convertida em [Runnable];
  • linhas 40–47: a função [process] (a camada [business]) chama a função [dao] (a camada [dao]) sem lhe passar o usuário: cada uma o recupera por meio de [USER.get()] (linha 52);
  • linhas 22–28: um escopo em que [USER] é igual a [admin] contém um escopo aninhado (linha 24) em que ele é igual a [guest]. Ao sair do escopo aninhado, voltamos a encontrar [admin]. Uma observação sobre a notação [where(…).run { … }]: a biblioteca padrão do Kotlin também tem uma função [run], aplicável a qualquer objeto ([obj.run { … }]). Aqui, é de fato o método [run] da classe [ScopedValue.Carrier] que é chamado, pois, em Kotlin, um método membro sempre tem precedência sobre uma função de extensão de mesmo nome. Os resultados confirmam isso: se a função [run] do Kotlin tivesse sido chamada, nenhum valor teria sido vinculado e [get] teria lançado uma exceção;
  • Linhas 27–28: uma thread criada dentro do escopo não enxerga a vinculação: ao contrário de um *[InheritableThreadLocal]*, um [ScopedValue] não é transmitido às threads criadas por *[Thread]. Ele é, no entanto, transmitido às subtarefas da concorrência estruturada ([StructuredTaskScope]*, em prévia no Java 25), que garante que essas subtarefas terminem antes do fim do escopo;
  • linhas 32–33: [call] executa uma operação dentro de um escopo e retorna seu resultado. Seu parâmetro é do tipo [ScopedValue.CallableOp<T, X>], em que [X] é o tipo das exceções (verificadas, em Java) que a operação pode lançar. O Kotlin não consegue inferir [X] a partir da lambda (ela não declara nenhuma exceção); sem os argumentos de tipo, o compilador relata:
error: cannot infer type for type parameter 'X'. Specify it explicitly.

Portanto, especificamos [call<String, RuntimeException>]: o resultado é um [String], e a operação não lança uma exceção verificada;

  • linha 36: depois dos escopos, o valor não está mais vinculado.

Resultados:

> gradlew -q run -Pmain=threads30.Threads30Kt
Outside any scope, is USER bound? false
get() out of scope: NoSuchElementException
[business] layer : USER = bob
[dao] layer : USER = bob
[business] layer : USER = alice
[dao] layer : USER = alice
outer scope : USER = admin
inner scope : USER = guest
back in the outer scope : USER = admin
child thread: bound? false
hello carole
After the scopes: bound? false, orElse: nobody

As mensagens das threads virtuais nas linhas 3–6 podem aparecer em outra ordem (bob antes de alice); o restante é reproduzível. Um [ScopedValue] é adequado para dados de contexto transmitidos “para baixo”, do chamador para as funções chamadas: usuário autenticado, transação, configurações regionais etc. Quando uma função chamada precisa modificar os dados para o processamento seguinte, é necessário um [ThreadLocal].

8.12.4. Aplicação: uma transação compartilhada entre camadas

Considere a seguinte aplicação de três camadas, na qual a camada [dao] gerencia uma tabela de artigos:

Image

Suponha que a interface da camada [dao] seja inicialmente a seguinte:

1
2
3
4
5
interface IDao {
    fun insertArticle(article: Article): Int
    fun getAllArticles(): List<Article>
    fun deleteAllArticles()
}

Mais tarde, surge a necessidade de inserir uma lista de artigos dentro de uma transação, pois a exigência é tudo ou nada: ou todos os artigos são inseridos, ou nenhum. Uma função [insertArticles(articles: List<Article>)] pode ser adicionada à interface. Depois, para outra aplicação, surge a necessidade de excluir uma lista de artigos, novamente dentro de uma transação… Para atender a diferentes necessidades de negócio, a camada [dao] vai crescer. Podemos adotar outra abordagem:

  • incluir apenas as operações básicas (inserir, atualizar, excluir, ler um artigo) na camada [dao];
  • mover para a camada [business] as operações que atualizam vários artigos simultaneamente. Essas operações usam as operações básicas da camada [dao].

A vantagem dessa solução é que a mesma camada [dao] pode ser usada sem modificação com diferentes camadas [business]. Ela introduz um desafio no gerenciamento da transação que agrupa as atualizações a serem executadas de forma atômica:

  • a transação deve ser iniciada pela camada [business] antes de ela chamar as funções da camada [dao];
  • as funções da camada [dao] devem conhecer a existência da transação para poder participar dela;
  • a transação deve ser concluída (confirmada ou revertida) pela camada [business].

Para que as funções da camada [dao] conheçam uma eventual transação em andamento, a transação poderia ser adicionada como parâmetro de cada função da camada [dao]. Esse parâmetro apareceria então na assinatura das funções da interface, vinculando-a a uma fonte de dados específica. Os dados locais da thread oferecem uma solução mais elegante: a camada [business] coloca a transação nos dados locais da thread, e é ali que a camada [dao] a recupera. As assinaturas das funções da camada [dao] não precisam ser alteradas. Várias threads (vários usuários) podem trabalhar simultaneamente: cada uma tem sua própria transação.

Os bancos de dados serão abordados nos Capítulos 10 e 11. Para manter o foco nas threads, usamos aqui uma tabela em memória e uma transação simulada. O programa [Threads31.kt] reúne todas as camadas em um único arquivo-fonte. As entidades são as seguintes:

// um artigo
data class Article(
    val id: Int, val name: String, val price: Double, val currentStock: Int, val minimumStock: Int
)

// uma transação simulada: ela anota como desfazer cada atualização
class Transaction {
    companion object {
        private val counter = AtomicInteger()
    }

    private val undos = ArrayDeque<() -> Unit>()
    val number = counter.incrementAndGet()

    // registra a operação que desfaz uma atualização
    fun log(undo: () -> Unit) {
        undos.addFirst(undo)
    }

    // confirma a transação (commit): as atualizações são mantidas
    fun commit() {
        undos.clear()
    }

    // desfaz a transação (rollback): as atualizações são desfeitas, da última para a primeira
    fun rollback() {
        while (true) {
            val undo = undos.removeFirstOrNull() ?: break
            undo()
        }
    }
}

// os dados locais à thread compartilhados pelas camadas
object ThreadContext {
    // a transação atual da thread (null se não houver nenhuma)
    val transaction = ThreadLocal<Transaction?>()
}
  • linhas 2–3: um artigo é uma data class cujo identificador [id] é definido pela camada [dao];
  • linhas 7–29: uma transação simulada. Cada atualização feita dentro da transação registra a operação necessária para desfazê-la (função [log]); [commit] confirma a transação ignorando essas operações; [rollback] a reverte executando as operações de reversão, da última para a primeira. Uma operação de reversão é uma função do tipo [() -> Unit]: em Kotlin, um tipo funcional substitui a interface Java [Runnable]. As operações são armazenadas em uma pilha, neste caso um *[ArrayDeque] da biblioteca padrão do Kotlin (*[kotlin.collections.ArrayDeque], importado automaticamente): a função [addFirst] empilha no topo, a função [removeFirstOrNull] desempilha do topo e retorna [null] se a pilha estiver vazia. No laço de [rollback], o operador Elvis [?: break] sai do laço quando a pilha está vazia; caso contrário, a operação desempilhada é executada por [undo()]. Um banco de dados real funciona de maneira semelhante, usando um log de transações;
  • linhas 8–13: cada transação recebe um número único, a propriedade somente leitura [number], calculada quando o objeto é criado. Como transações podem ser criadas por várias threads simultaneamente, o contador, armazenado no objeto companheiro, é um [AtomicInteger], que é incrementado atomicamente;
  • linhas 35–37: os dados locais da thread compartilhados entre as camadas: a transação atual da thread, ou [null] se não houver nenhuma, daí o tipo [ThreadLocal<Transaction?>].

A camada [dao] é a seguinte:

// a camada [dao]: uma tabela de artigos em memória com uma restrição de unicidade sobre o nome
interface IDao {
    fun insertArticle(article: Article): Int
    fun getAllArticles(): List<Article>
    fun deleteAllArticles()
}

class Dao : IDao {
    // a tabela, compartilhada por todas as threads, e seu lock
    private val table = mutableListOf<Article>()
    private val lock = Any()
    private var nextId = 1

    override fun insertArticle(article: Article): Int {
        // há uma transação em andamento na thread atual?
        val transaction = ThreadContext.transaction.get()
        synchronized(lock) {
            check(table.none { it.name == article.name }) { "an article named [${article.name}] already exists" }
            val inserted = article.copy(id = nextId++)
            table += inserted
            // em uma transação, anotamos como desfazer a inserção
            transaction?.log {
                synchronized(lock) { table -= inserted }
            }
            val mode = if (transaction == null) "outside a transaction"
                       else "in transaction ${transaction.number}"
            val name = Thread.currentThread().name
            println("[$name] [dao] insertion of ${inserted.name} (id ${inserted.id}) $mode")
            return 1
        }
    }

    override fun getAllArticles(): List<Article> = synchronized(lock) { table.toList() }

    override fun deleteAllArticles() {
        synchronized(lock) { table.clear() }
    }
}
  • Linhas 10–11: a tabela de artigos, compartilhada por todas as threads. O acesso a ela é protegido pelo lock da linha 11;
  • linha 16: a função [insertArticle] recupera qualquer transação que a camada [business] tenha colocado nos dados locais da thread atual. Sua variável [transaction] é do tipo [Transaction?];
  • linha 18: a tabela tem uma restrição de unicidade nos nomes dos artigos: inserir um artigo com um nome que já existe lança uma exceção. A função Kotlin [check] (Capítulo 3) lança uma [IllegalStateException], com a mensagem calculada pela lambda, se a condição for falsa; a função [none] verifica que nenhum elemento da tabela satisfaz o predicado;
  • linhas 19–20: o registro inserido é uma cópia do registro recebido, com um identificador atribuído pela camada [dao]. Como uma data class somente leitura não pode ser modificada, um novo objeto é criado por meio da função [copy], que altera apenas a propriedade nomeada;
  • linhas 22–23: se houver uma transação, a camada [dao] participa registrando como desfazer a inserção. A chamada segura [?.] chama [log] somente se [transaction] não for igual a [null]. A lambda de reversão, passada como lambda final, captura a variável [inserted];
  • linhas 25–28: uma saída de rastreamento mostra a thread, o registro inserido e a eventual transação. No ramo [else], o compilador sabe que [transaction] não é [null] (conversão inteligente de tipo);
  • linha 33: a lista de artigos retornada é uma cópia da tabela ([table.toList()]), para que o chamador não a percorra enquanto outra thread a modifica. A função [synchronized] retorna o valor de seu bloco.

A camada [business] é a seguinte:

// a camada [business]
interface IBusiness {
    fun insertArticlesInTransaction(articles: List<Article>)
    fun insertArticlesOutOfTransaction(articles: List<Article>)
    fun getAllArticles(): List<Article>
    fun deleteAllArticles()
}

class Business(private val dao: IDao) : IBusiness {
    // inserção de uma lista de artigos: tudo ou nada
    override fun insertArticlesInTransaction(articles: List<Article>) {
        val name = Thread.currentThread().name
        // início da transação, armazenada nos dados locais à thread
        val transaction = Transaction()
        ThreadContext.transaction.set(transaction)
        try {
            for (article in articles) {
                // a camada [dao] encontrará a transação na thread
                dao.insertArticle(article)
                // processamento simulado, que dá tempo para outras threads intervirem
                sleep(200)
            }
            transaction.commit()
            println("[$name] [business] transaction ${transaction.number} committed")
        } catch (e: RuntimeException) {
            transaction.rollback()
            println("[$name] [business] transaction ${transaction.number} rolled back")
            // a exceção é relançada para o chamador
            throw e
        } finally {
            // a thread não tem mais transação em andamento
            ThreadContext.transaction.remove()
        }
    }

    // inserção de uma lista de artigos sem transação
    override fun insertArticlesOutOfTransaction(articles: List<Article>) {
        articles.forEach(dao::insertArticle)
    }

    override fun getAllArticles(): List<Article> = dao.getAllArticles()

    override fun deleteAllArticles() = dao.deleteAllArticles()
}
  • linha 9: a camada [dao] é injetada pelo construtor primário, o que a torna uma propriedade privada;
  • linhas 14–15: a função [insertArticlesInTransaction] inicia uma transação e a salva nos dados locais da thread;
  • linha 19: a função de inserção da camada [dao] é chamada para cada artigo, sem lhe passar a transação;
  • linha 21: uma pausa simula um processamento, para dar a outra thread tempo de intervir durante a transação (terceira parte do programa de teste);
  • linha 23: se o programa chega a este ponto, nenhuma exceção ocorreu: a transação é confirmada;
  • linhas 25–29: se ocorrer uma exceção, a transação é revertida e a exceção é relançada ao chamador;
  • linha 32: em todos os casos, a thread deixa de ter uma transação ativa: [remove()] limpa o valor da thread. Isso é essencial se a thread for reutilizada (uma thread de pool);
  • linhas 37–38: a mesma inserção, sem transação. A referência vinculada [dao::insertArticle] aponta para a função [insertArticle] do objeto [dao];
  • As duas últimas funções delegam seu trabalho à camada [dao], com um corpo reduzido a uma única expressão.

O programa de teste é o seguinte:

fun main() {
    // as camadas da aplicação
    val dao: IDao = Dao()
    val business: IBusiness = Business(dao)
    Thread.currentThread().name = "Main"

    // dois artigos com o mesmo nome: o segundo viola a restrição de unicidade sobre o nome
    val articles = listOf(Article(0, "article", 100.0, 10, 1), Article(0, "article", 100.0, 10, 1))

    // 1 - inserção fora de uma transação
    println("Inserting the articles outside a transaction...")
    execute { business.insertArticlesOutOfTransaction(articles) }
    displayArticles(business)

    // 2 - inserção em uma transação
    business.deleteAllArticles()
    println("Inserting the articles in a transaction...")
    execute { business.insertArticlesInTransaction(articles) }
    displayArticles(business)

    // 3 - duas threads simultâneas: a transação da thread A não é vista pela thread B
    business.deleteAllArticles()
    println("Two simultaneous threads...")
    val articlesA = listOf(Article(0, "keyboard", 20.0, 5, 1), Article(0, "mouse", 10.0, 5, 1),
        Article(0, "keyboard", 20.0, 5, 1))
    val articlesB = listOf(Article(0, "screen", 150.0, 2, 1))
    val threadA = thread(name = "A") { execute { business.insertArticlesInTransaction(articlesA) } }
    Thread.sleep(100)
    val threadB = thread(name = "B") { execute { business.insertArticlesOutOfTransaction(articlesB) } }
    threadA.join()
    threadB.join()
    displayArticles(business)
}

// executa uma ação, exibindo a exceção, se houver
fun execute(action: () -> Unit) {
    try {
        action()
    } catch (e: RuntimeException) {
        println("[${Thread.currentThread().name}] ${e::class.simpleName} : ${e.message}")
    }
}

// dormir por [ms] milissegundos
fun sleep(ms: Long) {
    try {
        Thread.sleep(ms)
    } catch (_: InterruptedException) {
        Thread.currentThread().interrupt()
    }
}

// exibe a lista de artigos
fun displayArticles(business: IBusiness) {
    println("List of articles:")
    for (article in business.getAllArticles()) {
        println("  $article")
    }
}
  • Linha 8: é criada uma lista de dois artigos com o mesmo nome. A inserção do segundo artigo será rejeitada. Se a inserção for feita fora de uma transação, o primeiro artigo é inserido e permanece na lista. Se for feita dentro de uma transação, o primeiro artigo é inserido e depois removido quando a transação é revertida;
  • Linhas 11–13: inserem a lista fora de uma transação e, em seguida, exibem a tabela;
  • linhas 16–19: o mesmo que acima, mas dentro de uma transação;
  • linhas 22–31: duas threads são executadas simultaneamente. A thread A insere três artigos dentro de uma transação (o terceiro viola a restrição de unicidade); enquanto isso, a thread B, iniciada um décimo de segundo depois, insere um artigo fora de uma transação;
  • linhas 36–40: a função [execute] executa uma ação do tipo [() -> Unit] e exibe qualquer exceção, precedida do nome da thread. Ela é chamada com uma lambda final: [executer { … }].

Resultados:

> gradlew -q run -Pmain=threads31.Threads31Kt
Inserting the articles outside a transaction...
[Main] [dao] insertion of article (id 1) outside a transaction
[Main] IllegalStateException : an article named [article] already exists
List of articles:
  Article(id=1, name=article, price=100.0, currentStock=10, minimumStock=1)
Inserting the articles in a transaction...
[Main] [dao] insertion of article (id 2) in transaction 1
[Main] [business] transaction 1 rolled back
[Main] IllegalStateException : an article named [article] already exists
List of articles:
Two simultaneous threads...
[A] [dao] insertion of keyboard (id 3) in transaction 2
[B] [dao] insertion of screen (id 4) outside a transaction
[A] [dao] insertion of mouse (id 5) in transaction 2
[A] [business] transaction 2 rolled back
[A] IllegalStateException : an article named [keyboard] already exists
List of articles:
  Article(id=4, name=screen, price=150.0, currentStock=2, minimumStock=1)
  • A inserção fora de uma transação deixou o primeiro registro na tabela (linha 5). A função [toString] gerada para uma data class exibe o nome e o valor de cada uma de suas propriedades;
  • A inserção feita dentro de uma transação não deixou nenhum artigo na tabela: o artigo de id 2 foi removido pela reversão;
  • Na terceira parte, a thread B inseriu o monitor enquanto a transação 2 da thread A estava em andamento: ela o fez fora de uma transação, pois a transação é uma variável local da thread A. A reversão da transação 2 removeu o teclado e o mouse inseridos por A, mas não o monitor inserido por B. Esse resultado é reproduzível.

8.12.5. Conclusão

O exemplo anterior demonstrou o valor dos dados locais da thread para o gerenciamento de transações. Ele não deve ser replicado exatamente como foi mostrado, mas descreve com fidelidade o funcionamento dos frameworks: o gerenciamento de transações do Spring (anotação [@Transactional]) coloca a transação e a conexão com o banco de dados em [ThreadLocal], que as camadas de acesso a dados consultam sem que seu código precise manipular a transação; o Hibernate também pode associar a sessão de trabalho à thread atual. Voltaremos a essas ferramentas no Capítulo 11. Em código novo, particularmente com threads virtuais, um *[ScopedValue]* é a forma recomendada de transmitir esse tipo de informação de contexto; com corrotinas, esse papel cabe ao contexto da corrotina (Capítulo 9).

8.13. Para saber mais

A sincronização de threads é um campo difícil. Este capítulo apresentou as principais ferramentas; para se aprofundar:

  • o livro de Brian Goetz et al., [Java Concurrency in Practice] (Addison-Wesley), que continua sendo a referência definitiva sobre o assunto, embora seja anterior às threads virtuais. Seus exemplos estão em Java, mas tudo o que ele diz se aplica ao Kotlin na JVM;
  • a seção “Concurrency” do tutorial Java da Oracle: Lesson: Concurrency — é antigo, mas ainda correto no que diz respeito ao básico;
  • a documentação do pacote [java.util.concurrent]: Package java.util.concurrent, cuja seção “Memory Consistency Properties” resume as relações “acontece antes”;
  • a documentação do pacote [kotlin.concurrent] da biblioteca padrão do Kotlin ([thread], [withLock], [read], [write], [getOrSet]…): kotlin.concurrent;
  • as propostas de melhoria do Java (JEP) que introduziram as threads virtuais e os valores com escopo: JEP 444: Virtual Threads e JEP 506: Scoped Values.

No código moderno, raramente se manipulam diretamente objetos ([Thread]). Em Java, prefere-se usar executores ([ExecutorService]), streams paralelos para cálculos e threads virtuais para tarefas que envolvem espera. O Kotlin tem todas essas ferramentas, mas oferece uma solução própria, apresentada no próximo capítulo: as corrotinas. Uma corrotina é uma tarefa que pode se suspender (durante um acesso à rede, a um banco de dados ou a um arquivo) sem bloquear a thread que a executa, e depois retomar, possivelmente em outra thread; a concorrência estruturada garante que nenhuma corrotina seja esquecida e que erros e cancelamentos se propaguem corretamente. Os conceitos deste capítulo são, no entanto, essenciais: as corrotinas são executadas em threads, e os dados que elas compartilham devem ser protegidos com as mesmas ferramentas (locks, classes atômicas, coleções concorrentes) ou com seus equivalentes para corrotinas ([Mutex], [Channel]…).