Como trabalha com operações assíncronas?

Utilizo os seguintes mecanismos:

• Corutinas (Kotlin Coroutines): Método preferido para concorrência estruturada. Permitem escrever código assíncrono em estilo imperativo.
  • launch: Inicia uma nova corutina em segundo plano.
  • async/await: Executa uma operação assíncrona e retorna o resultado (Deferred).
  • Contextos (Dispatchers): Definem o grupo de threads para executar a corutina (Main, IO, Default).
  • Concurrência estruturada: As áreas de alcance (CoroutineScope) cancelam automaticamente as corutinas filhas ao cancelar a parent.
• RxJava (Extensões reativas para Java): Trabalhar com fluxos de dados assíncronos.
  • Observable/Flowable: Emitem uma sequência de elementos.
  • Operadores (map, filter, flatMap, etc.): Transformação e combinação de fluxos.
  • Planificadores (Schedulers): Definem os threads para executar operações.
• Callbacks: Mecanismo simples para chamadas de retorno ao completar uma operação. Pode levar a "Callback Hell" em lógica complexa.
• AsyncTask (obsoleto): Usado para realizar operações prolongadas em segundo plano e atualizar a UI no thread principal. Não recomendado em novos projetos.
• Threads (Fios Java): Mecanismo de baixo nível para gerenciar threads. Requer gestão manual do ciclo de vida e sincronização.

Exemplo de uso de corutinas:

// Executar operação assíncrona em thread IO e atualizar UI em thread Main
lifecycleScope.launch(Dispatchers.IO) {
    val data = fetchDataFromNetwork() // Operação longa
    withContext(Dispatchers.Main) {
        updateUI(data) // Atualizar UI
    }
}

Exemplo de uso de RxJava:

// Exemplo de obter dados da rede e processar o resultado
Observable.fromCallable(() -> fetchDataFromNetwork())
    .subscribeOn(Schedulers.io()) // Executar em thread IO
    .observeOn(AndroidSchedulers.mainThread()) // Obter resultado na thread principal
    .subscribe(data -> updateUI(data), error -> handleError(error));

A escolha do mecanismo depende da tarefa: corutinas para programação assíncrona geral, RxJava para trabalhar com fluxos de dados, callbacks para casos simples.