[2026] Rust 소유권 에러 디버깅 실전 사례 | borrow checker가 막아요 해결기

2026년 3월 30일 · 22분 읽기 · 수정 2026년 4월 7일 중급

이 글의 핵심

Rust 초보자가 자주 겪는 소유권, 빌림, 수명 에러를 실전 사례로 해결하는 방법. borrow checker 에러 메시지 읽는 법부터 RefCell, Rc, Arc 활용까지 다룹니다.

들어가며

“C++에서는 되는데 Rust에서는 왜 안 되나요?” Rust를 처음 배울 때 가장 많이 하는 말입니다. 이 글에서는 실제로 겪은 소유권 에러 사례를 통해 borrow checker를 이해하고 해결하는 방법을 다룹니다. 일상에 빗대면, 도서관 책을 빌린 상태에서 표지를 뜯어 가져오려는 것과 비슷합니다. 빌린 것은 반납할 때까지 통째로 있어야 하고, 필요하면 복사본을 새로 만들거나 참조만 읽어야 합니다.

이 글을 읽으면

Borrow checker 에러 메시지를 읽는 법을 배웁니다
소유권, 빌림, 수명의 관계를 실전에서 이해합니다
RefCell, Rc, Arc 등 해결 패턴을 익힙니다
Rust의 메모리 안전성을 활용하는 방법을 습득합니다

실무에서 마주한 현실

개발을 배울 때는 모든 게 깔끔하고 이론적입니다. 하지만 실무는 다릅니다. 레거시 코드와 씨름하고, 급한 일정에 쫓기고, 예상치 못한 버그와 마주합니다. 이 글에서 다루는 내용도 처음엔 이론으로 배웠지만, 실제 프로젝트에 적용하면서 “아, 이래서 이렇게 설계하는구나” 하고 깨달은 것들입니다. 특히 기억에 남는 건 첫 프로젝트에서 겪은 시행착오입니다. 책에서 배운 대로 했는데 왜 안 되는지 몰라 며칠을 헤맸죠. 결국 선배 개발자의 코드 리뷰를 통해 문제를 발견했고, 그 과정에서 많은 걸 배웠습니다. 이 글에서는 이론뿐 아니라 실전에서 마주칠 수 있는 함정들과 해결 방법을 함께 다루겠습니다.

1. 사례 1: “cannot move out of borrowed content”

이 사례의 흐름은 (1) 컴파일러가 빌린 user에서 필드를 옮기려 한 것을 막고, (2) 참조로 읽거나, clone으로 복사해 소유권을 분리하는 순서로 해결합니다.

문제 코드

아래 코드는 rust를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

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);
    }
}

에러 메시지

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

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은 소유권 이동을 시도
하지만 빌린 데이터에서는 소유권을 가져올 수 없음!

해결 방법

다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 방법 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”

문제 코드

다음은 rust를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

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()); // 💥 두 번째 가변 빌림!
        }
    }
}

에러 메시지

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

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는 동시에 하나의 가변 참조만 허용

해결 방법

다음은 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()
    }
}

에러 메시지

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

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

해결 방법

다음은 rust를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 방법 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”

문제 코드

아래 코드는 rust를 사용한 구현 예제입니다. 함수를 통해 로직을 구현합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

fn get_default_user() -> &User {
    let user = User {
        name: "Guest".to_string(),
        email: "guest@example.com".to_string(),
    };
    &user // ❌ user는 함수 끝에서 소멸
}

에러 메시지

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

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

해결 방법

다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 방법 1: 소유권 반환
fn get_default_user() -> User {
    User {
        name: "Guest".to_string(),
        email: "guest@example.com".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: "guest@example.com".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: "guest@example.com".to_string(),
    })
}

5. 사례 5: 멀티스레드

일상 비유로 이해하기: 동시성은 주방에서 여러 요리를 동시에 하는 것과 비슷합니다. 한 명의 요리사(싱글 스레드)가 국을 끓이다가 불을 줄이고, 그 사이에 야채를 썰고, 다시 국을 확인하는 식이죠. 반면 병렬성은 요리사 여러 명(멀티 스레드)이 각자 다른 요리를 동시에 만드는 겁니다. 공유 상태 {#case-5}

문제 코드

다음은 rust를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

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();
}

에러 메시지

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

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

해결 방법

다음은 rust를 활용한 상세한 구현 코드입니다. 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 방법 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>`	순환 참조 방지	상황에 따라

조합 패턴

다음은 rust를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// 단일 스레드: 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. 디버깅 팁

에러 메시지 읽는 법

아래 코드는 code를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

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

아래 코드는 bash를 사용한 구현 예제입니다. 에러 처리를 통해 안정성을 확보합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

$ rustc --explain E0502
This error indicates that you are trying to borrow a value as mutable when it
is already borrowed as immutable.
...

Clippy 활용

아래 코드는 bash를 사용한 구현 예제입니다. 비동기 처리를 통해 효율적으로 작업을 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

$ 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`을 고려하세요.

실전 체크리스트

Borrow Checker 에러 해결 체크리스트

에러 메시지 정확히 읽기
빌림 범위 확인 (어디서 시작, 어디까지 사용)
소유권이 필요한지 참조만 필요한지 판단
가변/불변 빌림 구분
수명 관계 확인
적절한 패턴 선택 (Rc, RefCell, Arc, Mutex)
Clippy로 추가 검사

멀티스레드 안전성 체크리스트

키워드

Rust, Ownership, 소유권, Borrow Checker, 빌림, Lifetime, 수명, RefCell, Rc, Arc, Mutex, 실전 사례, 디버깅, 에러 해결

이 글의 핵심

들어가며

이 글을 읽으면

실무에서 마주한 현실

목차

1. 사례 1: “cannot move out of borrowed content”

문제 코드

에러 메시지

왜 에러인가?

해결 방법

2. 사례 2: “cannot borrow as mutable more than once”

문제 코드

에러 메시지

왜 에러인가?

해결 방법

3. 사례 3: “lifetime may not live long enough”

문제 코드

에러 메시지

해결 방법

4. 사례 4: “cannot return reference to local variable”

문제 코드

에러 메시지

해결 방법

5. 사례 5: 멀티스레드

문제 코드

에러 메시지

해결 방법

6. 패턴 정리: 언제 무엇을 쓰나

소유권 vs 빌림

내부 가변성

공유 소유권

조합 패턴

7. 실전 예제: 이벤트 시스템

C++ 스타일 (컴파일 안 됨)

Rust 스타일 (Rc + RefCell)

8. 디버깅 팁

에러 메시지 읽는 법

rustc —explain

Clippy 활용

마무리

FAQ

관련 글

실전 체크리스트

Borrow Checker 에러 해결 체크리스트

멀티스레드 안전성 체크리스트

키워드