Como é que é garantida a possibilidade de suspender a execução de uma função com o modificador suspend?

A suspensão de funções é garantida pelo mecanismo de corrutinas e continuações.

1. Modificador suspend: Indica ao compilador que a função pode ser suspensa e retomada mais tarde sem bloquear a thread. Isso não significa que ela será obrigatoriamente suspensa.

2. Transformação pelo compilador: O compilador converte a função suspend numa máquina de estados. Esta máquina acompanha o ponto atual de execução da função e as suas variáveis locais.

3. Continuação (Continuation): Ao chamar uma função suspend, é passado um parâmetro oculto do tipo Continuation. Este objeto Continuation contém um callback que é chamado após a operação assíncrona que causou a suspensão terminar. Ele também armazena o contexto de execução da coroutine (planificador, contexto de tarefa, etc.).

4. Suspensão: Quando a função suspend atinge um ponto onde é necessário realizar uma operação assíncrona (por exemplo, uma requisição de rede, leitura de base de dados), em vez de bloquear a thread, ela captura o estado atual (variáveis locais, ponto de execução), guarda-o no objeto Continuation e devolve o controlo ao código chamador. A thread é libertada para realizar outras tarefas.

5. Reinício: Quando a operação assíncrona termina, o callback associado (guardado em Continuation) é chamado. Este callback notifica a coroutine de que pode retomar. A coroutine usa o estado guardado em Continuation para restaurar o contexto de execução e continua a partir do ponto onde foi suspensa.

// Exemplo: função suspend que simula um atraso
suspend fun fetchData(): String {
    // Aqui ocorre a suspensão.
    // A coroutine guarda o estado e liberta a thread.
    delay(1000) // função suspend do kotlinx.coroutines
    // Após 1000 ms, o callback de Continuation é chamado,
    // e a coroutine retoma a execução a partir deste ponto.
    return "Dados carregados"
}