러스트(Rust) 메모리 순서의 모든 것: 안전한 동시성 프로그래밍 완전 정복!

러스트(Rust) 메모리 순서의 모든 것: 안전한 동시성 프로그래밍 완전 정복!

동시성 프로그래밍의 세계에서는 메모리 연산 순서를 올바르게 관리하는 것이 프로그램의 정확성을 보장하는 데 아주 중요한데요.

러스트(Rust)는 원자적 연산(atomic operation)과 Ordering 열거형(enumeration)을 제공해서, 개발자들이 멀티스레드(multithreaded) 환경에서 공유 데이터를 안전하고 효율적으로 다룰 수 있도록 도와준답니다.

이 글에서는 러스트(Rust)의 Ordering 원리와 사용법을 자세히 소개해서, 개발자 여러분이 이 강력한 도구를 더 잘 이해하고 활용할 수 있도록 돕는 것을 목표로 한답니다.

메모리 순서의 기본 개념

현대의 프로세서와 컴파일러는 성능을 최적화하기 위해 명령어와 메모리 연산의 순서를 재배치하는데요.

이런 순서 변경은 보통 단일 스레드 프로그램에서는 문제를 일으키지 않지만, 멀티스레드(multithreaded) 환경에서는 제대로 제어하지 않으면 데이터 경쟁(data race)이나 일관성 없는 상태를 초래할 수 있습니다.

이 문제를 해결하기 위해 메모리 순서라는 개념이 도입되었고, 개발자들은 원자적 연산(atomic operation)에 메모리 순서를 지정해서 동시성 환경에서 메모리 접근이 올바르게 동기화되도록 보장할 수 있게 되었답니다.

러스트(Rust)의 Ordering 열거형(Enumeration)

러스트(Rust) 표준 라이브러리의 Ordering 열거형(enumeration)은 다양한 수준의 메모리 순서 보장을 제공해서, 개발자들이 특정 요구사항에 맞춰 적절한 순서 모델을 선택할 수 있게 한답니다.

러스트(Rust)에서 사용할 수 있는 메모리 순서 옵션들은 다음과 같은데요.

Relaxed (완화된 순서)

Relaxed는 가장 기본적인 보장을 제공합니다.

단일 원자적 연산(atomic operation)의 원자성은 보장하지만, 연산들 사이의 순서는 보장하지 않는답니다.

이건 간단한 카운팅이나 상태 표시에 적합한데요.

연산의 상대적 순서가 프로그램의 정확성에 영향을 미치지 않는 경우에 사용됩니다.

Acquire (획득) 및 Release (해제)

Acquire와 Release는 연산의 부분적인 순서를 제어합니다.

Acquire는 현재 스레드가 일치하는 Release 연산에 의해 이루어진 수정 사항을 확인한 후에야 후속 연산을 실행하도록 보장한답니다.

이건 보통 잠금(lock)이나 다른 동기화 프리미티브(synchronization primitive)를 구현하는 데 사용되어, 리소스에 접근하기 전에 제대로 초기화되었음을 보장합니다.

AcqRel (획득-해제)

AcqRel은 Acquire와 Release의 효과를 결합한 것인데요.

값을 읽고 수정하는 연산 모두에 적합하며, 이러한 연산들이 다른 스레드에 대해 순서대로 이루어지도록 보장합니다.

SeqCst (순차적 일관성)

SeqCst, 즉 순차적 일관성(sequential consistency)은 가장 강력한 순서 보장을 제공합니다.

모든 스레드가 연산을 동일한 순서로 보도록 보장해서, 전역적으로 일관된 실행 순서가 필요한 시나리오에 적합합니다.

Ordering의 실제 사용법

적절한 Ordering을 선택하는 것은 아주 중요한데요.

너무 완화된 순서를 사용하면 프로그램에 논리적 오류가 생길 수 있고, 반대로 너무 엄격한 순서를 사용하면 불필요하게 성능이 저하될 수 있습니다.

아래에는 Ordering 사용법을 보여주는 몇 가지 러스트(Rust) 코드 예제가 있답니다.

예제 1: 멀티스레드 환경에서 정렬된 접근을 위한 Relaxed 사용하기

이 예제는 멀티스레드(multithreaded) 환경에서 간단한 카운팅 연산에 Relaxed 순서를 사용하는 방법을 보여주는데요.

use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

fn main() { // main 함수 추가
    let counter = AtomicUsize::new(0); // AtomicUsize 타입의 원자적 카운터, 0으로 초기화

    // Arc를 사용해 counter의 소유권을 스레드로 넘기고 메인 스레드에서도 접근 가능하게 합니다.
    // 하지만 이 간단한 예제에서는 counter를 직접 move해도 됩니다.
    // 좀 더 복잡한 시나리오나 여러 스레드가 공유하려면 Arc가 필요합니다.
    // 여기서는 join()을 사용하므로 Arc 없이 counter를 move 시킵니다.

    let handle = thread::spawn(move || { // 새 스레드를 생성합니다.
        // fetch_add 연산으로 counter 값을 1 증가시킵니다.
        counter.fetch_add(1, Ordering::Relaxed); 
    });

    handle.join().unwrap(); // 스레드가 끝날 때까지 기다립니다.

    // counter 값을 읽어옵니다.
    println!("Counter: {}", counter.load(Ordering::Relaxed)); 
}

여기서는 AtomicUsize 타입의 원자적 카운터 counter를 만들고 0으로 초기화합니다.


thread::spawn을 사용해 새 스레드를 만들고, 그 안에서 counter에 대해 fetch_add 연산을 수행하여 값을 1 증가시킨답니다.


Ordering::Relaxed는 증가 연산이 원자적으로 수행됨을 보장하지만, 연산 순서는 보장하지 않습니다.

즉, 여러 스레드가 동시에 counter에 fetch_add를 수행하면 모든 연산이 안전하게 완료되지만, 실행 순서는 예측할 수 없다는 의미입니다.


Relaxed는 특정 연산 순서보다는 최종 개수만 중요한 간단한 카운팅 시나리오에 적합합니다.

예제 2: Acquire와 Release를 사용하여 데이터 접근 동기화하기

이 예제는 두 스레드 간의 데이터 접근을 동기화하기 위해 Acquire와 Release를 사용하는 방법을 보여주는데요.

use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
use std::thread;
use std::time::Duration; // 잠시 대기하기 위해 추가

fn main() { // main 함수 추가
    // 데이터 준비 여부를 나타내는 AtomicBool 플래그, false로 초기화
    let data_ready = Arc::new(AtomicBool::new(false)); 
    let data_ready_clone_producer = Arc::clone(&data_ready); // 생산자 스레드용 클론
    let data_ready_clone_consumer = Arc::clone(&data_ready); // 소비자 스레드용 클론

    // 생산자 스레드
    let producer_handle = thread::spawn(move || {
        // 데이터 준비하는 작업 (시뮬레이션)
        println!("Producer: Preparing data...");
        thread::sleep(Duration::from_secs(1)); // 1초 동안 데이터 준비 시뮬레이션
        println!("Producer: Data is ready!");
        // store 메서드와 Ordering::Release를 사용해 data_ready를 true로 업데이트
        data_ready_clone_producer.store(true, Ordering::Release); 
    });

    // 소비자 스레드
    let consumer_handle = thread::spawn(move || {
        // data_ready 값이 true가 될 때까지 반복해서 확인
        while !data_ready_clone_consumer.load(Ordering::Acquire) { 
            // 데이터가 준비될 때까지 기다립니다. (실제로는 스핀락이므로 CPU 사용)
            // 좀 더 효율적인 방법은 condition variable 등을 사용하는 것입니다.
            println!("Consumer: Waiting for data...");
            thread::sleep(Duration::from_millis(100)); // 짧게 대기
        }
        // 이제 생산자가 준비한 데이터에 안전하게 접근할 수 있습니다.
        println!("Consumer: Data received, processing..."); 
    });

    producer_handle.join().unwrap();
    consumer_handle.join().unwrap();
}

여기서는 데이터 준비 여부를 나타내는 AtomicBool 플래그 data_ready를 만들고 false로 초기화합니다.


Arc를 사용해서 여러 스레드 간에 data_ready를 안전하게 공유한답니다.


생산자 스레드는 데이터를 준비한 다음 store 메서드와 Ordering::Release를 사용해 data_ready를 true로 업데이트하여 데이터가 준비되었음을 알립니다.


소비자 스레드는 load 메서드와 Ordering::Acquire를 사용해 루프 안에서 data_ready 값이 true가 될 때까지 계속 확인합니다.


여기서 Acquire와 Release는 함께 사용되어, 생산자가 data_ready를 true로 설정하기 전에 수행한 모든 연산이 소비자 스레드가 준비된 데이터에 접근하기 전에 보이도록 보장합니다.

예제 3: 읽기-수정-쓰기 연산에 AcqRel 사용하기

이 예제는 읽기-수정-쓰기 연산 중에 올바른 동기화를 보장하기 위해 AcqRel을 사용하는 방법을 보여주는데요.

use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
use std::thread;

fn main() { // main 함수 추가
    let some_value = Arc::new(AtomicUsize::new(0));
    let some_value_clone = Arc::clone(&some_value);

    // 수정 스레드
    let modification_handle = thread::spawn(move || {
        // 여기서 `fetch_add`는 값을 읽고 수정하므로 `AcqRel`을 사용합니다.
        let old_value = some_value_clone.fetch_add(1, Ordering::AcqRel);
        println!("Modification Thread: Previous value was {}, new value is {}", old_value, old_value + 1);
    });

    modification_handle.join().unwrap();

    // SeqCst는 가장 강력한 순서 보장이므로, 다른 스레드의 변경 사항을 확실히 볼 수 있습니다.
    println!("Main Thread: some_value: {}", some_value.load(Ordering::SeqCst)); 
}

AcqRel은 Acquire와 Release의 조합으로, 데이터를 읽고(acquire) 수정하는(release) 연산에 적합합니다.


이 예제에서 fetch_add는 읽기-수정-쓰기(RMW, Read-Modify-Write) 연산인데요.

먼저 some_value의 현재 값을 읽고, 1을 더한 다음, 마지막으로 새 값을 다시 씁니다.

이 연산은 다음을 보장합니다.

• 읽은 값은 최신 값입니다. 즉, (다른 스레드에서 수행되었을 수 있는) 이전의 모든 수정 사항이 현재 스레드에 보입니다 (Acquire 시맨틱).
  
  
• some_value에 대한 수정 사항은 즉시 다른 스레드에 보입니다 (Release 시맨틱).
  
  

AcqRel을 사용하면 다음이 보장됩니다.

• fetch_add 이전의 모든 읽기 또는 쓰기 연산은 그 이후로 재배치되지 않습니다.
  
  
• fetch_add 이후의 모든 읽기 또는 쓰기 연산은 그 이전으로 재배치되지 않습니다.
  
  
  이것은 some_value를 수정할 때 올바른 동기화를 보장합니다.
  
  

예제 4: SeqCst를 사용하여 전역 순서 보장하기

이 예제는 전역적으로 일관된 연산 순서를 보장하기 위해 SeqCst를 사용하는 방법을 보여주는데요.

use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

fn main() { // main 함수 추가
    let counter = Arc::new(AtomicUsize::new(0)); // Arc로 감싸서 스레드 간 공유
    let counter_clone1 = Arc::clone(&counter);
    let counter_clone2 = Arc::clone(&counter); // 두 번째 스레드를 위한 클론

    let handle1 = thread::spawn(move || {
        counter_clone1.fetch_add(1, Ordering::SeqCst); // SeqCst 사용
        println!("Thread 1 incremented");
    });

    let handle2 = thread::spawn(move || { // 또 다른 스레드 예시
        counter_clone2.fetch_add(1, Ordering::SeqCst); // SeqCst 사용
        println!("Thread 2 incremented");
    });

    handle1.join().unwrap();
    handle2.join().unwrap();

    // 모든 스레드의 SeqCst 연산이 완료된 후 최종 값을 읽습니다.
    println!("Counter: {}", counter.load(Ordering::SeqCst)); 
}

예제 1과 유사하게, 이 코드도 카운터에 대한 원자적 증가 연산을 수행합니다.


차이점은 여기서 Ordering::SeqCst를 사용한다는 점인데요.

SeqCst는 가장 엄격한 메모리 순서로, 개별 연산의 원자성뿐만 아니라 전역적으로 일관된 실행 순서도 보장합니다.


SeqCst는 다음과 같이 강력한 일관성이 필요할 때만 사용해야 합니다.

• 시간 동기화
  
  
• 멀티플레이어 게임에서의 동기화
  
  
• 상태 머신 동기화 등
  
  

SeqCst를 사용하면 모든 스레드에 걸쳐 모든 SeqCst 연산이 단일하고, 전역적으로 합의된 순서로 실행되는 것처럼 보인답니다.

이것은 연산의 정확한 순서를 유지해야 하는 시나리오에서 유용합니다.

---