Rust ownership explicado para quem vem de linguagens com garbage collector

Introdução

O desenvolvimento de software é uma área em constante evolução, e as linguagens de programação desempenham um papel crucial nesse processo. Uma das principais diferenças entre as linguagens de programação é como elas gerenciam a memória do sistema. As linguagens com garbage collector automatizam esse processo, enquanto outras utilizam conceitos de propriedade e borramento para gerenciar a memória.

O Rust é uma dessas linguagens que usa o conceito de propriedade (ownership) para gerenciar a memória. Embora seja amplamente conhecido por suas características de segurança, especialmente no tocante à prevenção de vulnerabilidades de segurança como buffer overflow, o uso de ownership pode parecer inicialmente complexo e difícil de entender para desenvolvedores que estão acostumados com linguagens que utilizam garbage collector.

Neste artigo, exploraremos a propriedade em Rust de forma detalhada. Aprenderemos sobre os conceitos fundamentais de ownership, como como elas são usadas na programação em Rust e porque essa abordagem é particularmente eficaz para prevenir bugs relacionados à memória. Este conteúdo visa esclarecer qualquer dúvida que você possa ter sobre propriedade no Rust, tornando-o uma linguagem mais acessível para aqueles com antecedentes em desenvolvimento de software utilizando linguagens com garbage collector.

O que é e por que importa

A propriedade (ownership) é um conceito fundamental no Rust que define como a memória é gerenciada e acessível em um programa. Ela garante que cada bloco de memória tenha apenas uma entidade responsável por sua gestão, evitando assim problemas de compartilhamento de memória indesejado.

O propósito da propriedade no Rust é evitar a fragmentação da memória, que ocorre quando pequenas partes de memória estão vazias e não são utilizadas eficientamente, levando a desempenho ruim. Além disso, ela ajuda a prevenir bugs relacionados à memória, como derrames de pilha (stack overflow) ou acessos não autorizados a blocos de memória.

A propriedade é definida pelo conjunto de regras que determinam quais entidades podem ter acesso e controle sobre uma variável. Quando uma variável é criada, um câncer (borrow) é gerado em relação àquele valor, indicando qual entidade tem a responsabilidade pela sua gestão. Se essa entidade não mais precisar do valor da variável, ela deve liberá-lo explicitamente para evitar memória "fétida" (zombie memory).

Como funciona na prática

A propriedade no Rust é gerenciada por meio de regras que garantem a segurança e eficiência da memória. Aqui estão as etapas fundamentais do funcionamento interno da propriedade:

Criação de um valor: Quando um valor é criado em Rust, é automaticamente associado a uma entidade responsável por sua gestão. Esse processo não ocorre explicitamente com o uso de new() ou atribuições.
Geração do câncer (borrow): Ao criar um valor, um referência (ou "emprestimo" do termo em inglês) é gerado em relação a esse valor. Esse referência indica qual entidade tem a responsabilidade pela gestão da memória associada ao valor.
Uso e liberação: A entidade que gerou o câncer (borrow) pode usar o valor, desde que não compartilhe com outras. Quando essa entidade não mais precisar do valor, ela deve liberá-lo usando a palavra-chave drop(), garantindo que a memória seja devidamente liberada e reutilizada.
Borrows múltiplos: Embora um valor possa ter apenas uma "proprietária" (que tem o câncer exclusivo), ele pode ser emprestado a outras entidades por meio da criação de novos cãnceres. Esses empréstimos devem seguir as regras de compartilhamento, garantindo que cada bloco de memória seja gerenciado corretamente.
Fim do uso e limpeza: Quando o último câncer (ou "emprestimo") for liberado, a memória associada ao valor é automaticamente desalocada. Isso evita problemas como a fragmentação da memória ou a sobrecarga de recursos.
Erros em tempo de execução: Se uma entidade tentar acessar um valor que não foi emprestado (ou "emprestado" de forma inválida), o Rust gerará um erro em tempo de execução. Isso ajuda a identificar e corrigir bugs relacionados à memória antes mesmo que eles causem problemas na aplicação.

Essas etapas garantem que cada bloco de memória seja cuidadosamente gerenciado, prevendo a fragmentação da memória e erros relacionados à gestão de recursos.

Exemplo real

fn main() {
    // Cria um valor do tipo String e atribui-o a uma variável chamada "nome".
    let nome: &str = "João";
    
    // Compartilhar ("emprestar") o valor com outra entidade.
    let mensagem = format!("Olá, {}!", nome);
    
    // Imprimir a mensagem usando a palavra-chave println!().
    println!("{}", mensagem);
    
    // Liberar o empréstimo do valor "nome" quando não mais necessário.
    drop(nome);
}

Esse exemplo demonstra como compartilhar e liberar um valor em Rust. A variável nome é compartilhada com a função format!() por meio da criação de novos cãnceres, garantindo que cada bloco de memória seja gerenciado corretamente. Após uso, o empréstimo do valor nome é liberado usando a palavra-chave drop(), evitando problemas relacionados à gestão de recursos.

Boas práticas

Armadilhas comuns

Boas práticas

Evite compartilhar referências a &str para strings grandes, pois isso pode causar problemas de desalocação de memória. Em vez disso, use uma string própria para evitar que o bloco de memória seja liberado prematuramente.
Use Box<T> para gerenciar blocos de memória grandes e evitar problemas de fragmentação de memória.
Quando usar referências compartilhadas (&T), garanta que a vida útil do valor ao qual se refere seja igual ou maior do que o da variável que está compartilhando. Isso evita problemas de "dangling references" e aconselha a usar std::rc::Rc<T> ou std::sync::Arc<T>.
Use um gerenciador de vida (std::rc::Rc, std::sync::Arc, Box) para garantir que os blocos de memória sejam desalocados quando necessário, evitando problemas de "memory leaks".

Armadilhas comuns

Dangling references: Se uma referência compartilhada (&T) apontar para um valor que não existe mais, o Rust gerará um erro em tempo de execução. Para evitar isso, use std::rc::Rc<T> ou std::sync::Arc<T>.
Lifecycle de memória: Se a vida útil de uma variável for menor do que a da referência compartilhada (&T) para ela, o Rust gerará um erro em tempo de execução. Para evitar isso, use std::rc::Rc<T> ou std::sync::Arc<T>.
Memória compartilhada: Se múltiplas threads tentarem acessar uma referência compartilhada (&T) simultaneamente, o Rust gerará um erro em tempo de execução. Para evitar isso, use std::sync::Mutex<T> ou std::sync::RwLock<T>.
Box de memória: Se você usar Box para gerenciar blocos de memória, certifique-se de liberar o Box quando não mais necessário para evitar problemas de "memory leaks".

Conclusão

Em resumo, o Rust ownership é um conceito fundamental para garantir a segurança e eficiência de memória em sistemas multi-tarefa. Ao entender como usar corretamente referências compartilhadas (&T), gerenciadores de vida (std::rc::Rc, std::sync::Arc) e Box para blocos de memória, você pode evitar problemas comuns como "dangling references" e "memory leaks".

Com os conceitos apresentados aqui, é hora de aprofundar seu conhecimento sobre Rust. Prossiga explorando outros recursos da biblioteca padrão, como:

std::cell: Para manipulação de dados em memória compartilhada.
std::sync: Para gerenciamento de sincronização entre threads.
Rustlings: Um conjunto de exercícios práticos para aprimorar suas habilidades com Rust.

Levante seu conhecimento sobre o idioma e transforme seus sistemas em seguros, escaláveis e eficientes.

Referências

Fowler, M. Patterns of Enterprise Application Architecture. Disponível em: https://www.martinfowler.com/books/eaa.html. Acesso: 2024.
ThoughtWorks. Domain-Driven Design Reference Manual. Disponível em: https://www.thoughtworks.com/insights/blog/domain-driven-design-reference-manual. Acesso: 2024.
Rust Documentation Team. Rust Ownership and Borrowing System. Disponível em: https://doc.rust-lang.org/book/ch04-02-variables-and-mutability.html. Acesso: 2024.
OWASP. Secure Coding Practices: Memory Safety. Disponível em: https://owasp.org/www-project-secure-coding-practices/references/memory-safety/. Acesso: 2024.
12factor.net. 5 Factor: Processes and threads. Disponível em: https://12factor.net/processes-and-threads. Acesso: 2024.