Rust 소유권 에러 디버깅 실전 사례 | "borrow checker가 막아요" 해결기
이 글의 핵심
Rust 소유권 에러 실전 해결 - borrow checker 이해, RefCell, Rc, Arc 활용법
들어가며
“C++에서는 되는데 Rust에서는 왜 안 되나요?” Rust를 처음 배울 때 가장 많이 하는 말입니다. 이 글에서는 실제로 겪은 소유권 에러 사례를 통해 borrow checker를 이해하고 해결하는 방법을 다룹니다.
일상에 빗대면, 도서관 책을 빌린 상태에서 표지를 뜯어 가져오려는 것과 비슷합니다. 빌린 것은 반납할 때까지 통째로 있어야 하고, 필요하면 복사본을 새로 만들거나 참조만 읽어야 합니다.
이 글을 읽으면
- Borrow checker 에러 메시지를 읽는 법을 배웁니다
- 소유권, 빌림, 수명의 관계를 실전에서 이해합니다
- RefCell, Rc, Arc 등 해결 패턴을 익힙니다
- Rust의 메모리 안전성을 활용하는 방법을 습득합니다
목차
- 사례 1: “cannot move out of borrowed content”
- 사례 2: “cannot borrow as mutable more than once”
- 사례 3: “lifetime may not live long enough”
- 사례 4: “cannot return reference to local variable”
- 사례 5: 멀티스레드 공유 상태
- 패턴 정리: 언제 무엇을 쓰나
- 마무리
1. 사례 1: “cannot move out of borrowed content”
이 사례의 흐름은 (1) 컴파일러가 빌린 user에서 필드를 옮기려 한 것을 막고, (2) 참조로 읽거나, clone으로 복사해 소유권을 분리하는 순서로 해결합니다.
문제 코드
struct User {
name: String,
email: String,
}
fn process_users(users: &Vec<User>) {
for user in users {
let name = user.name; // ❌ cannot move out of `user.name`
println!("Processing: {}", name);
}
}에러 메시지
error[E0507]: cannot move out of `user.name` which is behind a shared reference
--> src/main.rs:8:20
|
8 | let name = user.name;
| ^^^^^^^^^ move occurs because `user.name` has type `String`, which does not implement the `Copy` trait왜 에러인가?
users는 불변 참조 (&Vec<User>)user.name은String(소유권 타입)let name = user.name은 소유권 이동을 시도- 하지만 빌린 데이터에서는 소유권을 가져올 수 없음!
해결 방법
// 방법 1: 참조만 사용
fn process_users(users: &Vec<User>) {
for user in users {
let name = &user.name; // ✅ 참조
println!("Processing: {}", name);
}
}
// 방법 2: 복사
fn process_users(users: &Vec<User>) {
for user in users {
let name = user.name.clone(); // ✅ 복사
println!("Processing: {}", name);
}
}
// 방법 3: 소유권 받기
fn process_users(users: Vec<User>) { // &를 제거
for user in users {
let name = user.name; // ✅ 소유권 이동
println!("Processing: {}", name);
}
}2. 사례 2: “cannot borrow as mutable more than once”
문제 코드
struct ChatRoom {
users: Vec<User>,
messages: Vec<String>,
}
impl ChatRoom {
fn broadcast(&mut self, sender: &User) {
let msg = format!("{}: Hello", sender.name);
// ❌ cannot borrow `self` as mutable more than once
for user in &mut self.users {
self.messages.push(msg.clone()); // 💥 두 번째 가변 빌림!
}
}
}에러 메시지
error[E0499]: cannot borrow `self.messages` as mutable more than once at a time
--> src/main.rs:12:13
|
10 | for user in &mut self.users {
| --------------- first mutable borrow occurs here
11 | self.messages.push(msg.clone());
| ^^^^^^^^^^^^^ second mutable borrow occurs here왜 에러인가?
&mut self.users로 첫 번째 가변 빌림self.messages.push()로 두 번째 가변 빌림 시도- Rust는 동시에 하나의 가변 참조만 허용
해결 방법
// 방법 1: 필드 분리 빌림
impl ChatRoom {
fn broadcast(&mut self, sender: &User) {
let msg = format!("{}: Hello", sender.name);
// users와 messages를 따로 빌림
let users = &mut self.users;
let messages = &mut self.messages;
for user in users {
messages.push(msg.clone()); // ✅ 다른 필드
}
}
}
// 방법 2: 반복 전에 메시지 생성
impl ChatRoom {
fn broadcast(&mut self, sender: &User) {
let msg = format!("{}: Hello", sender.name);
self.messages.push(msg.clone()); // 먼저 추가
for user in &mut self.users {
// messages는 더 이상 빌리지 않음
user.notify();
}
}
}
// 방법 3: 인덱스 사용
impl ChatRoom {
fn broadcast(&mut self, sender: &User) {
let msg = format!("{}: Hello", sender.name);
for i in 0..self.users.len() {
self.messages.push(msg.clone()); // ✅ 인덱스는 빌림 아님
}
}
}3. 사례 3: “lifetime may not live long enough”
문제 코드
struct UserCache {
users: Vec<User>,
}
impl UserCache {
fn find(&self, name: &str) -> Option<&User> {
self.users.iter().find(|u| u.name == name)
}
fn get_or_create(&mut self, name: &str) -> &User {
// ❌ lifetime 에러
if let Some(user) = self.find(name) {
return user; // 💥 빌림이 살아있는데 &mut self 필요
}
self.users.push(User { name: name.to_string(), email: String::new() });
self.users.last().unwrap()
}
}에러 메시지
error[E0502]: cannot borrow `self.users` as mutable because it is also borrowed as immutable
--> src/main.rs:15:9
|
12 | if let Some(user) = self.find(name) {
| ---- immutable borrow occurs here
13 | return user;
| ---- returning this value requires that `*self` is borrowed for `'1`
...
15 | self.users.push(...);
| ^^^^^^^^^^^ mutable borrow occurs here해결 방법
// 방법 1: 인덱스 사용
impl UserCache {
fn get_or_create(&mut self, name: &str) -> &User {
// 먼저 인덱스 찾기
if let Some(idx) = self.users.iter().position(|u| u.name == name) {
return &self.users[idx]; // ✅ 새로운 빌림
}
self.users.push(User { name: name.to_string(), email: String::new() });
self.users.last().unwrap()
}
}
// 방법 2: Entry API (HashMap)
use std::collections::HashMap;
struct UserCache {
users: HashMap<String, User>,
}
impl UserCache {
fn get_or_create(&mut self, name: &str) -> &User {
self.users.entry(name.to_string())
.or_insert_with(|| User { name: name.to_string(), email: String::new() })
}
}4. 사례 4: “cannot return reference to local variable”
문제 코드
fn get_default_user() -> &User {
let user = User {
name: "Guest".to_string(),
email: "[email protected]".to_string(),
};
&user // ❌ user는 함수 끝에서 소멸
}에러 메시지
error[E0515]: cannot return reference to local variable `user`
--> src/main.rs:8:5
|
8 | &user
| ^^^^^ returns a reference to data owned by the current function해결 방법
// 방법 1: 소유권 반환
fn get_default_user() -> User {
User {
name: "Guest".to_string(),
email: "[email protected]".to_string(),
}
}
// 방법 2: 정적 수명
fn get_default_user() -> &'static User {
static DEFAULT: User = User {
name: String::new(), // ❌ const fn이 아니라 안 됨
};
&DEFAULT
}
// 방법 2-1: lazy_static 사용
use lazy_static::lazy_static;
lazy_static! {
static ref DEFAULT_USER: User = User {
name: "Guest".to_string(),
email: "[email protected]".to_string(),
};
}
fn get_default_user() -> &'static User {
&DEFAULT_USER
}
// 방법 3: Box로 힙 할당
fn get_default_user() -> Box<User> {
Box::new(User {
name: "Guest".to_string(),
email: "[email protected]".to_string(),
})
}5. 사례 5: 멀티스레드 공유 상태
문제 코드
use std::thread;
struct Counter {
count: i32,
}
fn main() {
let counter = Counter { count: 0 };
let handle = thread::spawn(|| {
counter.count += 1; // ❌ closure may outlive the current function
});
handle.join().unwrap();
}에러 메시지
error[E0373]: closure may outlive the current function, but it borrows `counter`, which is owned by the current function
--> src/main.rs:9:31
|
9 | let handle = thread::spawn(|| {
| ^^ may outlive borrowed value `counter`
10 | counter.count += 1;
| ------- `counter` is borrowed here해결 방법
// 방법 1: Arc + Mutex (멀티스레드 안전)
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut count = counter_clone.lock().unwrap();
*count += 1;
});
handle.join().unwrap();
println!("Count: {}", *counter.lock().unwrap());
}
// 방법 2: 채널 사용 (메시지 전달)
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(1).unwrap();
});
let count = rx.recv().unwrap();
println!("Count: {}", count);
}
// 방법 3: 원자적 타입 (AtomicI32)
use std::sync::atomic::{AtomicI32, Ordering};
fn main() {
let counter = Arc::new(AtomicI32::new(0));
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
counter_clone.fetch_add(1, Ordering::SeqCst);
});
handle.join().unwrap();
println!("Count: {}", counter.load(Ordering::SeqCst));
}6. 패턴 정리: 언제 무엇을 쓰나
소유권 vs 빌림
| 상황 | 해결 방법 | 예시 |
|---|---|---|
| 읽기만 필요 | 불변 참조 &T | fn print(user: &User) |
| 수정 필요 | 가변 참조 &mut T | fn update(user: &mut User) |
| 소유권 필요 | 값 T | fn consume(user: User) |
| 복사 가능 | Copy 트레이트 | fn calc(x: i32) |
내부 가변성
| 타입 | 용도 | 스레드 안전 |
|---|---|---|
Cell<T> | Copy 타입 내부 가변성 | ❌ |
RefCell<T> | 런타임 빌림 검사 | ❌ |
Mutex<T> | 멀티스레드 가변성 | ✅ |
RwLock<T> | 읽기 많은 경우 | ✅ |
공유 소유권
| 타입 | 용도 | 스레드 안전 |
|---|---|---|
Rc<T> | 단일 스레드 공유 | ❌ |
Arc<T> | 멀티스레드 공유 | ✅ |
Weak<T> | 순환 참조 방지 | 상황에 따라 |
조합 패턴
// 단일 스레드: Rc + RefCell
use std::rc::Rc;
use std::cell::RefCell;
let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
let clone = Rc::clone(&shared);
shared.borrow_mut().push(4);
println!("{:?}", clone.borrow()); // [1, 2, 3, 4]
// 멀티스레드: Arc + Mutex
use std::sync::{Arc, Mutex};
let shared = Arc::new(Mutex::new(vec![1, 2, 3]));
let clone = Arc::clone(&shared);
thread::spawn(move || {
clone.lock().unwrap().push(4);
});7. 실전 예제: 이벤트 시스템
C++ 스타일 (컴파일 안 됨)
struct EventManager {
listeners: Vec<Box<dyn Fn(&Event)>>,
}
impl EventManager {
fn subscribe(&mut self, callback: impl Fn(&Event) + 'static) {
self.listeners.push(Box::new(callback));
}
fn publish(&self, event: &Event) {
for listener in &self.listeners {
listener(event); // ✅ 이건 괜찮음
}
}
}
// 문제: 구독자가 EventManager를 수정하려 하면?
fn main() {
let mut mgr = EventManager { listeners: vec![] };
mgr.subscribe(|event| {
mgr.publish(event); // ❌ cannot borrow `mgr` as mutable
});
}Rust 스타일 (Rc + RefCell)
use std::rc::Rc;
use std::cell::RefCell;
struct EventManager {
listeners: Vec<Box<dyn Fn(&Event)>>,
}
fn main() {
let mgr = Rc::new(RefCell::new(EventManager { listeners: vec![] }));
let mgr_clone = Rc::clone(&mgr);
mgr.borrow_mut().subscribe(Box::new(move |event| {
// 클로저 내부에서 mgr_clone 사용
mgr_clone.borrow().publish(event);
}));
}8. 디버깅 팁
에러 메시지 읽는 법
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> src/main.rs:10:5
|
8 | let r = &x;
| -- immutable borrow occurs here
9 |
10 | x.push(1);
| ^^^^^^^^^ mutable borrow occurs here
11 | println!("{}", r);
| - immutable borrow later used here읽는 순서:
- 에러 타입:
E0502(동시 빌림 불가) - 문제 위치: 10번 줄
- 원인: 8번 줄에서 불변 빌림
- 사용 위치: 11번 줄까지 사용
rustc —explain
$ rustc --explain E0502
This error indicates that you are trying to borrow a value as mutable when it
is already borrowed as immutable.
...Clippy 활용
$ cargo clippy
warning: this `RefCell` Ref is held across an 'await' point
--> src/main.rs:10:9
|
10 | let data = cell.borrow();
| ^^^^
|
= help: consider using a `Mutex` instead마무리
Rust의 borrow checker는 처음엔 답답하지만, 컴파일 타임에 메모리 안전성을 보장해줍니다. 이 사례들을 통해:
- 에러 메시지를 정확히 읽는 법을 배웠습니다
- 소유권, 빌림, 수명의 관계를 이해했습니다
- RefCell, Rc, Arc 등 해결 패턴을 익혔습니다
- C++와 다른 사고방식을 습득했습니다
핵심: Borrow checker와 싸우지 말고, Rust의 철학을 이해하고 따르세요.
FAQ
Q1. Rust는 C++보다 어려운가요?
초기 학습 곡선은 가파르지만, 익숙해지면 메모리 버그를 원천 차단할 수 있습니다.
Q2. RefCell을 남용하면 안 되나요?
RefCell은 런타임 검사이므로 panic 가능성이 있습니다. 가능하면 컴파일 타임 빌림을 사용하세요.
Q3. Arc<Mutex
네, 오버헤드가 있습니다. 필요한 곳에만 사용하고, 읽기가 많으면 RwLock을 고려하세요.
관련 글
- Rust 소유권 완벽 가이드
- Rust 빌림과 참조
- Rust 수명
- Rust 스마트 포인터
실전 체크리스트
Borrow Checker 에러 해결 체크리스트
- 에러 메시지 정확히 읽기
- 빌림 범위 확인 (어디서 시작, 어디까지 사용)
- 소유권이 필요한지 참조만 필요한지 판단
- 가변/불변 빌림 구분
- 수명 관계 확인
- 적절한 패턴 선택 (Rc, RefCell, Arc, Mutex)
- Clippy로 추가 검사
멀티스레드 안전성 체크리스트
- Send/Sync 트레이트 확인
- Arc + Mutex 조합 고려
- 데드락 가능성 검토
- 채널 사용 고려
- 원자적 타입 활용
키워드
Rust, Ownership, 소유권, Borrow Checker, 빌림, Lifetime, 수명, RefCell, Rc, Arc, Mutex, 실전 사례, 디버깅, 에러 해결