[Rust] lock 동기화: Mutex, RwLock

러스트에서 스레드를 사용해서 동시성을 구현할 때는, 러스트의 근엄한 규칙에 따라 항상 안전한 동기화 기능을 이용해야 한다.

그럴때 사용하는게 채널이나 Atomic, 그리고 Lock인데, 오늘은 Lock 중에서도 자주 사용하는 Mutex와 RWLock을 다뤄보겠다.

Mutex

Mutex는 내부 가변성 패턴을 구현한 스마트 포인터 타입 중 하나다.

Rust뿐만 아니라 범용적으로 다 쓰이는 기술인데, 바이너리 세마포어라고도 부른다.

내부적으로 lock 플래그값을 하나 두고, 스레드에서 lock()으로 접근하면 다른 스레드에서의 잠금을 차단하고, lock()이 drop되면 잠근이 풀리는 형태로 엄격한 serialize를 구현한다. 한번에 한놈만 들어오게 하는 것이다.

매우 단순하고 강력하지만, 성능의 손실과 데드락을 항상 경계해야한다.

아래와 같은 형태로 사용할 수 있다.

use std::sync::{Arc, Mutex};

fn main() {
    let mutex = Arc::new(Mutex::new(10));

    println!("start");
    {
        let a = mutex.lock().unwrap(); // lock 획득

        println!("a: {}", a);
    } // a의 unlock은 여기서 발생
    println!("end");
}

Mutex 같은 Lock 타입이나, Atomic 타입들은 Arc로 감싸서 사용하는게 기본이다. 그래야 스레드 간에 복제가 가능해지기 때문이다.
그리고 lock 함수를 통해서 원본 값에 접근 가능한 MutexGuard라는 유사 포인터 객체를 반환한다. 이걸로 락을 거는 것이고, 이 MutexGuard가 drop되면 unlock이 되는 것이다.

가장 주의해야할 케이스인 데드락을 한번 보겠다.
아래 코드는 데드락이 발생하는 코드다.
무심코 짤 수도 있는, 매우 간단한 형태의 코드임에도

use std::sync::{Arc, Mutex};

fn main() {
    let mutex = Arc::new(Mutex::new(10));

    println!("start");
    {
        let a = mutex.lock().unwrap(); // lock 획득
        let b = mutex.lock().unwrap(); // lock 대기중...

        println!("a: {}, b: {}", a, b);
    } // a의 unlock은 여기서 발생
    println!("end");
}

데드락이 터진다.
첫번째로 호출한 lock 객체는 분명히 저 스코프를 벗어나야 해제가 된다.
근데 그러기도 전에 두번째로 lock을 호출하니, 말도 안되는 무한루프에 걸리게 된 것이다.
최대한 이런 상황이 발생하지 않게 유의해야 한다.

그래서 lock을 걸때는 최대한 이런 식으로 스코프를 엄격하게 제한해야 한다.

그럼 lock이 바로바로 풀리니 데드락은 어느정도 회피할 수 있다.
물론 상호참조하면서 더럽게 꼬여있을때는 한땀한땀 디버깅하면서 풀어야한다.

RwLock

RwLock은 다중 read 작업에 최적화된 Lock이다.

Mutex의 경우에는 read&write 기능이 분리되어있지 않고, lock을 할때 반환되는 값은 읽기와 쓰기를 전부 할 수 있다.
그런데 쓰기에 비하면 읽기 작업은 멀티스레드환경에서도 상당히 안정적인 기능이고, 보통은 좀더 동시적으로 발생해도 무방한 편이다. 하지만 Mutex는 그런것을 구분하지 못하기 때문에.. 읽기만 하더라도 주구장창 lock을 걸어야 한다는게 좀 단점이 될 수 있다.

RwLock은 Mutex의 그러한 단점을 보완하는 Lock 타입이다.
그래서 읽기 락과 쓰기 락을 분리해서 구현한다.

엄청나게 큰 차이가 발생한 것은 아니다.
기본적인 규칙은 이렇다.

1. write 락이 걸려있을 때는 다른 모든 스레드가 대기한다.

2. read 락이 걸려있을 때는 모든 read를 동시에 허용한다. 단, write는 대기시킨다.

그래서 아래와 같이 동시에 read를 시도하더라도, 데드락이 발생하지 않는다.

use std::sync::{Arc, RwLock};

fn main() {
    let mutex = Arc::new(RwLock::new(10));

    println!("start");
    {
        let a = mutex.read().unwrap();
        let b = mutex.read().unwrap();

        println!("a: {}, b: {}", a, b);
    }
    println!("end");
}

하지만 이렇게 write와 read가 혼재될 때는 Mutex와 마찬가지로 얼마든지 데드락이 발생할 수 있다.

use std::{
    borrow::BorrowMut,
    sync::{Arc, RwLock},
};

fn main() {
    let mutex = Arc::new(RwLock::new(10));

    println!("start");
    {
        let mut w: std::sync::RwLockWriteGuard<i32> = mutex.write().unwrap(); // write lock 획득
        w.borrow_mut().clone_from(&10);
        let a = mutex.read().unwrap(); // read 대기
        let b = mutex.read().unwrap();
        mutex.write().unwrap().clone_from(&20);

        println!("a: {}, b: {}", a, b);
    }
    println!("end");
}

아무튼 그래서 쓰기가 적고 읽기가 굉장히 많을 때는 RwLock이 매우 적합하다고 할 수 있다.
그 반대로 쓰시가 많을 때는 mpsc channel 같은게 좋겠고...
primitive만 써도 되는 경우에는 Atomic이 가볍고 빠르다.

Mutex는 그 사이의 애매한 지점일 때 사용하면 되지 않나 싶다.

참조
https://onesignal.com/blog/thread-safety-rust/
https://doc.rust-lang.org/std/sync/struct.RwLock.html
https://stackoverflow.com/questions/50704279/when-or-why-should-i-use-a-mutex-over-an-rwlock