Com base no trecho de código precedente, escrito em Rust, que cria um contador, julgue o item a seguir.A instrução let counter = Arc::new(0); combina exclusão mútua com contagem atômica de referência e garante acesso seguro e exclusivo a dados entre threads.
CCerto
EErrado
Revelar gabarito e comentário▾
GabaritoE — Errado
Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.
Arc<T> em Rust: contagem atômica de referência, não exclusão mútua
Gabarito: ERRADO. A instrução let counter = Arc::new(0); cria um contador atômico de referência (Arc = Atomic Reference Counting), que permite que múltiplas threads compartilhem o mesmo valor com segurança, mas não fornece exclusão mútua — o Arc apenas garante que a contagem de referências seja atômica, não que o acesso ao dado interno seja exclusivo. Para exclusão mútua, seria necessário combinar o Arc com um Mutex (ou RwLock), como em Arc<Mutex<i32>>.
O Arc<T> é um tipo de ponteiro inteligente da biblioteca padrão do Rust projetado para compartilhamento de dados entre threads. A palavra "atômico" em seu nome refere-se exclusivamente à contagem de referências — o mecanismo que rastreia quantos ponteiros apontam para o mesmo dado e que permite a liberação automática da memória quando o último ponteiro é destruído. Essa contagem é feita de forma atômica (ou seja, segura contra corridas de dados), mas o dado em si (T) permanece imutável e acessível a todas as threads que possuem um clone do Arc. Não há nenhum mecanismo de bloqueio ou exclusão mútua embutido no Arc.
Para entender a distinção, é útil comparar os principais tipos de sincronização do Rust:
Tipo
Função principal
Exclusão mútua?
Uso típico
Arc<T>
Compartilhamento de dados imutáveis entre threads
Não
Dados de leitura compartilhados
Mutex<T>
Exclusão mútua com bloqueio
Sim
Dados mutáveis acessados por uma thread por vez
RwLock<T>
Leitura concorrente / escrita exclusiva
Sim (na escrita)
Dados com mais leituras que escritas
AtomicUsize
Operações atômicas em inteiros
Não (mas operações indivisíveis)
Contadores, flags
Na prática, quando se deseja um contador compartilhado e mutável entre threads, a combinação correta seria Arc<AtomicUsize> (para operações atômicas de incremento/decremento) ou Arc<Mutex<i32>> (para exclusão mútua com um inteiro comum). O código Arc::new(0) cria um Arc apontando para um inteiro imutável 0 — qualquer tentativa de modificá-lo exigiria um tipo com mutabilidade interior, como Mutex ou AtomicUsize.
A pegadinha da banca está em atribuir ao Arc uma propriedade que ele não possui: a exclusão mútua. O candidato que conhece apenas o nome "atômico" pode ser induzido a pensar que o Arc oferece acesso exclusivo, mas o termo "atômico" qualifica apenas a contagem de referências, não o acesso ao dado. É uma confusão clássica entre dois conceitos distintos de concorrência: compartilhamento seguro (que o Arc fornece) e exclusão mútua (que exige Mutex ou similar).
NÃO CAIA NESSA!
A banca explora a ambiguidade do termo "atômico" no nome Arc. O candidato pode pensar que "atômico" significa "acesso exclusivo", mas na verdade refere-se apenas à contagem de referências. O Arc garante que o dado seja compartilhado com segurança (sem corridas na contagem de referências), mas não impede que múltiplas threads acessem o dado simultaneamente. Para exclusão mútua, seria necessário Arc<Mutex<T>>.
Item — ❌ ERRADO
A afirmação de que Arc::new(0) "combina exclusão mútua com contagem atômica de referência" é incorreta por dois motivos:
O Arc não fornece exclusão mútua. Ele é apenas um ponteiro inteligente com contagem atômica de referências. O dado interno (0, um inteiro) permanece imutável e pode ser lido por múltiplas threads simultaneamente, sem qualquer bloqueio.
A exclusão mútua exigiria um tipo adicional. Para acesso exclusivo a um dado mutável, seria necessário Arc<Mutex<i32>> ou Arc<RwLock<i32>>. O Arc sozinho não oferece nenhum mecanismo de bloqueio.
O que o Arc realmente garante é o compartilhamento seguro do dado entre threads: a contagem de referências é atômica, evitando corridas de dados quando o ponteiro é clonado e destruído. Mas o acesso ao dado em si não é exclusivo — é apenas imutável (a menos que se use mutabilidade interior).
Gabarito: ERRADO — o Arc fornece contagem atômica de referência, mas não exclusão mútua.
Com base no trecho de código precedente, escrito em Rust, que cria um contador, julgue o item a seguir.A instrução let counter = Arc::new(0); combina exclusão mútua com contagem atômica de referência e garante acesso seguro e exclusivo a dados entre threads.