Forem: Felipe Carvalho

Concorrência Moderna no Swift: async/await e actors explicados

Felipe Carvalho — Wed, 19 Mar 2025 08:21:39 +0000

Olá desenvolvedores! Se você está se aventurando no mundo do Swift e se perguntando como lidar com concorrência de maneira moderna e eficiente, este artigo é para você. Vamos explorar o sistema de concorrência introduzido no Swift 5.5, com foco em async/await e actors, e entender por que essas ferramentas são tão importantes para o desenvolvimento de aplicações robustas.

O problema: Concorrência é complicada

Aplicações modernas precisam fazer várias coisas ao mesmo tempo:

Baixar dados da internet enquanto a interface permanece responsiva
Processar imagens sem travar a aplicação
Lidar com múltiplas requisições de rede simultaneamente
Sincronizar dados entre diferentes threads

Antes do Swift 5.5, gerenciar essas operações era um grande desafio, sujeito a diversos problemas:

Race conditions: quando duas threads acessam e modificam dados compartilhados simultaneamente
Deadlocks: quando threads ficam bloqueadas esperando uma pela outra
Callback hell: código aninhado de difícil manutenção e leitura
Thread explosion: criar threads demais pode degradar a performance

O mundo antigo: Como fazíamos antes

Grand Central Dispatch (GCD)

O GCD foi por muito tempo a principal ferramenta para concorrência no iOS:

// Executando código em background
DispatchQueue.global().async {
    // Operação demorada
    let resultado = self.operacaoDemorada()

    // Volta para a main thread para atualizar UI
    DispatchQueue.main.async {
        self.atualizarUI(com: resultado)
    }
}

Completion Handlers (Callbacks)

Muito código assíncrono era escrito usando callbacks:

func buscarDados(completion: @escaping (Resultado) -> Void) {
    DispatchQueue.global().async {
        // Busca dados da rede
        let dados = self.downloadDados()

        // Callback com resultado
        DispatchQueue.main.async {
            completion(dados)
        }
    }
}

// Uso (potencial callback hell)
buscarDados { resultado in
    self.processarResultado(resultado) { dadosProcessados in
        self.salvarDados(dadosProcessados) { sucesso in
            if sucesso {
                self.mostrarMensagem("Sucesso!")
            }
        }
    }
}

Operation e OperationQueue

Uma abordagem mais estruturada, mas ainda complexa:

let operacao = BlockOperation {
    // Código a ser executado concorrentemente
}

let fila = OperationQueue()
fila.addOperation(operacao)

O novo mundo: Swift Concurrency

Com Swift 5.5, Apple introduziu um sistema de concorrência moderno e seguro que revolucionou como escrevemos código assíncrono.

async/await: Código assíncrono com aparência síncrona

O async/await permite escrever código assíncrono que parece síncrono:

// Função assíncrona
func buscarDados() async throws -> [Dado] {
    // Simula uma operação de rede
    try await Task.sleep(nanoseconds: 1_000_000_000) // 1 segundo
    return [Dado(id: 1), Dado(id: 2)]
}

// Uso em outra função assíncrona
func atualizarDados() async {
    do {
        let dados = try await buscarDados()
        // Não precisa de DispatchQueue.main.async
        atualizarUI(com: dados)
    } catch {
        mostrarErro(error)
    }
}

// Chamada a partir de código síncrono
func botaoAtualizar() {
    Task {
        await atualizarDados()
    }
}

Benefícios do async/await:

Legibilidade: código linear e fácil de seguir
Tratamento de erros nativo: uso de try/catch em vez de callback errors
Simplicidade: menos código e mais segurança
Manutenção: código mais fácil de depurar e modificar

Actor: Proteção de estado em ambientes concorrentes

Um actor é um tipo que garante acesso seguro ao seu estado mutável:

// Definição de um actor
actor Contador {
    private var valor = 0

    func incrementar() -> Int {
        valor += 1
        return valor
    }

    func obterValor() -> Int {
        return valor
    }
}

// Uso do actor
func exemplo() async {
    let contador = Contador()

    // Acesso seguro - isolamento automático
    let novoValor = await contador.incrementar()
    print("Novo valor: \(novoValor)")
}

Por que actors são importantes?

Segurança de thread: impossibilita race conditions no estado interno
Sincronização automática: o compilador garante acesso exclusivo ao estado
Simplicidade: sem necessidade de locks, semáforos ou outras primitivas manuais
Performance: otimizado pelo sistema runtime

Quando usar cada recurso?

Use async/await quando:

Precisar realizar operações que tomam tempo (rede, E/S, processamento pesado)
Quiser simplificar código assíncrono com uma sintaxe linear
Precisar lidar com operações que podem falhar (com throws)
Quiser compor múltiplas operações assíncronas

Use actor quando:

Tiver dados mutáveis que precisam ser acessados por múltiplas tarefas
Quiser evitar race conditions em state compartilhado
Precisar encapsular lógica que requer sincronização
Tiver uma classe que precisa ser thread-safe

Exemplo prático: Gerenciador de download de imagens

Vejamos um exemplo completo que combina ambos os conceitos para resolver um problema comum em apps iOS:

// Um actor que gerencia cache de imagens
actor ImageCache {
    private var cache: [URL: UIImage] = [:]

    func image(for url: URL) -> UIImage? {
        return cache[url]
    }

    func saveImage(_ image: UIImage, for url: URL) {
        cache[url] = image
    }

    func clearCache() {
        cache.removeAll()
    }
}

// Serviço de download de imagens
class ImageService {
    private let cache = ImageCache()

    func downloadImage(from url: URL) async throws -> UIImage {
        // Verifica se a imagem já está em cache
        if let cachedImage = await cache.image(for: url) {
            return cachedImage
        }

        // Faz download da imagem
        let (data, _) = try await URLSession.shared.data(from: url)

        guard let image = UIImage(data: data) else {
            throw URLError(.cannotDecodeContentData)
        }

        // Salva no cache
        await cache.saveImage(image, for: url)

        return image
    }
}

// Uso em uma ViewController
class ImageViewController: UIViewController {
    @IBOutlet weak var imageView: UIImageView!
    let imageService = ImageService()

    func loadImage() {
        // Mostra indicador de carregamento
        showLoadingIndicator()

        // Cria uma task para fazer o download
        Task {
            do {
                let url = URL(string: "https://exemplo.com/imagem.jpg")!
                let image = try await imageService.downloadImage(from: url)

                // Atualiza UI na main thread (não precisa de DispatchQueue.main.async)
                imageView.image = image
                hideLoadingIndicator()
            } catch {
                showError(error)
                hideLoadingIndicator()
            }
        }
    }
}

Neste exemplo:

ImageCache é um actor que protege o acesso concorrente ao dicionário de cache
ImageService usa async/await para fazer o download e gerenciar o cache
ImageViewController chama o serviço de forma assíncrona com Task

Vantagens do novo sistema de concorrência

Segurança: O compilador verifica o uso correto de await e actor, reduzindo bugs
Legibilidade: Código assíncrono linear e fácil de entender
Manutenção: Menos código para gerenciar threads e sincronização
Performance: O sistema runtime otimiza a execução das tarefas assíncronas
Interoperabilidade: Trabalha bem com código existente baseado em completion handlers

Dicas para migração

Se você está migrando de GCD ou completion handlers para o novo sistema:

Comece identificando funções que usam callbacks e converta-as para async
Use withCheckedContinuation para criar bridges entre código assíncrono antigo e novo
Substitua classes que precisam de thread-safety por actor
Aproveite as funcionalidades da API como TaskGroup para operações paralelas
Migre gradualmente - você pode misturar os dois sistemas durante a transição

Conclusão

O sistema de concorrência moderno do Swift representa um grande avanço na forma como lidamos com operações assíncronas. Com async/await e actors, o código se torna mais seguro, legível e fácil de manter.

Essas ferramentas não apenas resolvem problemas antigos como race conditions e callback hell, mas também abrem portas para novos padrões de design mais robustos e eficientes. Se você ainda não mergulhou nessas funcionalidades, agora é a hora!

E você, já está usando o sistema de concorrência moderno do Swift? Compartilhe suas experiências nos comentários abaixo!

Este artigo foi escrito para desenvolvedores Swift que querem entender melhor as ferramentas modernas de concorrência. Se gostou, não deixe de compartilhar e seguir para mais conteúdo sobre desenvolvimento iOS e Swift, bem como de Flutter e Dart.

ChatGPT: Seu Pato de Borracha Turbinado ou Apenas uma Colinha?

Felipe Carvalho — Wed, 25 Dec 2024 23:59:05 +0000

No mundo do desenvolvimento de software, todos conhecemos o bom e velho pato de borracha: aquele confidente silencioso para quem explicamos nosso código linha por linha, na esperança de iluminar a solução para um bug teimoso. Mas e se o seu pato pudesse não apenas ouvir, mas também entender e até mesmo sugerir soluções? É aí que entra o ChatGPT.

ChatGPT como Consultor (Pato de Borracha):

Entendimento contextual: O ChatGPT não apenas processa o código, mas também entende o contexto do seu problema. Você pode explicar a lógica, o objetivo e até mesmo as tentativas anteriores, recebendo opiniões mais relevantes.
Sugestões e alternativas: ao invés de apenas ouvir, o ChatGPT pode sugerir abordagens diferentes, identificar possíveis problemas de desempenho ou segurança e até mesmo gerar trechos de código para te dar um ponto de partida.
Aprendizado contínuo: A interação com o ChatGPT pode te ajudar a entender melhor conceitos complexos e aprimorar suas habilidades de resolução de problemas. É como ter um mentor sempre à disposição.

Estou com dificuldades para implementar um algoritmo de ordenação eficiente em Python para uma lista de objetos complexos. Atualmente, estou usando o sorted() com uma função key personalizada, mas o desempenho está muito lento para grandes conjuntos de dados. A função key compara vários atributos dos objetos. Poderia me ajudar a identificar possíveis gargalos e sugerir alternativas mais eficientes, como usar um algoritmo de ordenação diferente ou otimizar a função key? Gostaria de entender o porquê da sua sugestão e quais as vantagens em relação à minha abordagem atual.

ChatGPT como "Cola" (Codebase para Copiar e Colar):

Soluções rápidas, mas superficiais: usar o ChatGPT apenas para copiar e colar código pode parecer uma solução rápida no início, mas leva geralmente a problemas a longo prazo.
Falta de entendimento: você perde a oportunidade de aprender e entender a lógica por trás do código, o que dificulta a manutenção e a resolução de problemas futuros.
Dependência e estagnação: ao se tornar dependente da "cola", você pode acabar estagnado em seu desenvolvimento profissional, sem aprofundar seus conhecimentos.

Preciso de um código em Python que implemente um algoritmo de busca binária em uma lista ordenada de números inteiros.

A moral da história:

O ChatGPT é uma ferramenta poderosa que pode revolucionar como desenvolvemos software. Usá-lo como um consultor, um pato de borracha turbinado, permite um aprendizado mais profundo e soluções mais eficientes. Já o utilizar apenas como uma "cola" pode te levar a um beco sem saída.

Até a próxima...

Uma Simples Tela Criada Usando UIKit/ViewCode e Flutter

Felipe Carvalho — Mon, 18 Nov 2024 11:01:17 +0000

Criei uma tela bem simples com apenas três elementos dispostos verticalmente: um título, um campo de texto e um botão. Neste post, veremos qual tecnologia é mais simples de implementar. Neste exemplo, não me preocupei em explicar cada parte do código. Caso queiram, posso fazê-lo no futuro.

1️⃣ Usando UIKit e ViewCode:

Antes de iniciar a criação das telas programaticamente tive que remover todas as referências ao arquivo Main.storyboard e incluir o seguinte código no arquivo SceneDelegate.swift deixando o método scene assim:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
     // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
     // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
     // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
     guard let windowScene = (scene as? UIWindowScene) else { return }

     let window = UIWindow(windowScene: windowScene)
     let taskMasterVC = HomeViewController()
        window.rootViewController = UINavigationController(rootViewController: taskMasterVC)
     window.makeKeyAndVisible()
     self.window = window
}

Agora que está tudo configurado, criei uma interface ViewCode.swift para melhorar a implementação do ViewCode.

protocol ViewCode {
    func addSubviews()
    func setupConstraints()
    func setupStyles()
}

extension ViewCode {
    func setup() {
        addSubviews()
        setupConstraints()
        setupStyles()
    }
}

A View foi criada no arquivo HomeView.swift com o seguinte código contendo os elementos.

import UIKit

class HomeView: UIView {
    private lazy var titleLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.font = .systemFont(ofSize: 22, weight: .semibold)
        return label
    }()

    private lazy var textInputTask: UITextField = {
        let textField = UITextField()
        textField.translatesAutoresizingMaskIntoConstraints = false
        textField.placeholder = "Enter a task"
        textField.borderStyle = .roundedRect
        textField.layer.cornerRadius = 8
        return textField
    }()

    private lazy var addTaskBT: UIButton = {
        let button = UIButton()
        button.translatesAutoresizingMaskIntoConstraints = false
        button.setTitleColor(.white, for: .normal)
        button.backgroundColor = .systemBlue
        button.layer.cornerRadius = 8
        return button
    }()

    init() {
        super.init(frame: .zero)
        setup()
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func setup(titleText: String, addTaskButtonTitle: String) {
        titleLabel.text = titleText
        addTaskBT.setTitle(addTaskButtonTitle, for: .normal)
    }

}

extension HomeView: ViewCode {
    func addSubviews() {
        addSubview(titleLabel)
        addSubview(textInputTask)
        addSubview(addTaskBT)
    }

    func setupConstraints() {
        NSLayoutConstraint.activate(
            [
                titleLabel.topAnchor
                    .constraint(
                        equalTo: safeAreaLayoutGuide.topAnchor, constant: 12),
                titleLabel.centerXAnchor.constraint(equalTo: centerXAnchor),

                textInputTask.topAnchor
                    .constraint(equalTo: titleLabel.bottomAnchor, constant: 18),
                textInputTask.leadingAnchor
                    .constraint(equalTo: leadingAnchor, constant: 16),
                textInputTask.trailingAnchor
                    .constraint(equalTo: trailingAnchor, constant: -16),

                addTaskBT.topAnchor
                    .constraint(
                        equalTo: textInputTask.bottomAnchor, constant: 12),
                addTaskBT.centerXAnchor.constraint(equalTo: centerXAnchor),
                addTaskBT.widthAnchor.constraint(equalToConstant: 120),
            ]
        )
    }

    func setupStyles() {
        backgroundColor = .white
    }
}

Aqui podemos ver que o uso do protocolo ViewCode melhora a legibilidade e a organização, mas como podemos ver isso na tela do dispositivo? Agora entra o último arquivo: HomeViewController.swift.

import UIKit

class HomeViewController: UIViewController {

    private lazy var homeView: HomeView = {
        return HomeView()
    }()

    override func loadView() {
        super.loadView()
        self.view = homeView
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        homeView.setup(titleText: "Task Master", addTaskButtonTitle: "Add Task")
    }
}

Assim, criamos a seguinte tela:

Build ViewCode no iPhone

2️⃣ Usando Flutter:

No Flutter, como podemos criar builds tanto para Android quanto para iOS, usamos o mesmo código para ambos:

Poderíamos separar os componentes em arquivos, o que é uma boa prática. Mas, como neste exemplo não haverá reuso, deixei tudo no arquivo main.dart.

import 'package:flutter/material.dart';

void main() {
  runApp(const MainApp());
}

class MainApp extends StatelessWidget {
  const MainApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: SafeArea(
        child: Padding(
          padding: const EdgeInsets.only(top: 12, left: 16, right: 16),
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.center,
            children: [
              const Text(
                'Task Master',
                style: TextStyle(fontSize: 22, fontWeight: FontWeight.bold),
                textAlign: TextAlign.center,
              ),
              const SizedBox(height: 18),
              const TextField(
                decoration: InputDecoration(
                  border: OutlineInputBorder(),
                  labelText: 'Enter a task',
                ),
              ),
              const SizedBox(height: 12),
              ElevatedButton(
                onPressed: () {},
                style: ElevatedButton.styleFrom(
                  shape: RoundedRectangleBorder(
                    borderRadius: BorderRadius.circular(8),
                  ),
                  backgroundColor: Colors.blue,
                  foregroundColor: Colors.white,
                ),
                child: const Text('Add Task'),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

E foram geradas as seguintes telas:

Build Flutter no Android	Build Flutter no iPhone

Daria para deixar exatamente iguais? 🤔 Sim, daria, mas não quis me prolongar em relação a estilizar os componentes.

Caso encontre algum erro ou queira contribuir pode deixar nos comentários.

Em um próximo momento, falarei mais detalhadamente sobre cada parte do código.

Até lá!

🚀 Swift Tip: `for` vs `filter` para Filtragem de Listas

Felipe Carvalho — Wed, 13 Nov 2024 08:57:40 +0000

Ao trabalhar com arrays no Swift, você já se perguntou qual é a maneira mais performática de filtrar elementos? 🤔
Vamos ver um exemplo simples:

Temos duas formas de filtrar palavras com mais de 5 letras

1️⃣ Usando um loop `for`:

func moreThanFiveLetters(wordList: [String]) -> [String] {
    var result = [String]()
    result.reserveCapacity(wordList.count)
    for word in wordList {
        if word.count > 5 {
            result.append(word)
        }
    }
    return result
}

2️⃣ Usando `filter`:


func moreThanFiveLetters(wordList: [String]) -> [String] {
    wordList.filter { $0.count > 5 }
}

🔹 Qual é mais rápido?

Para listas pequenas, a diferença é quase imperceptível. Mas em listas maiores, a versão com for pode ser ligeiramente mais rápida se usarmos reserveCapacity.
Isso evita redimensionamentos repetidos do array enquanto ele é preenchido, otimizando o desempenho.

🔹 Conclusão:

Se você valoriza elegância e legibilidade, filter é uma escolha excelente.
Se está lidando com listas grandes e busca desempenho máximo, um loop for com reserveCapacity pode ser a melhor aposta.

👉 Escolha a abordagem que equilibra clareza e performance para o seu caso!

Sabemos que em programação há várias formas de implementar a resolução de um problema, como melhoraria essa?

Siga meu Instagram
Ou conecte LinkedIn