Openlab - 7차 Rust 스터디

lambda 24.07.23

138 4 0

facebook twitter kakao link

4 0

facebook twitter kakao link

DEVOTEE 요약: 7주차 스터디는 러스트의 동시성과 객체지향 프로그래밍을 다루었으며, 스레드, 메시지 패싱, Arc/Mutex, Sync와 Send 트레이트를 통해 안전한 동시성 구현 방법과 트레이트 객체를 이용한 다형성, 객체지향 디자인 패턴을 소개하였습니다. 동시성 부분에서 설명이 부족한 점은 아쉬웠지만, 책을 통해 많은 부분을 배웠습니다. 마지막 주까지 열심히 공부해 나가기로 했습니다.

DEVOTEE 추천 블로그

7주차 스터디는 7월 1일에 진행 했습니다.

길고 길었던 스터디는 어느덧 마지막 회차만 남겨두고 있습니다. 러스트에 대해 깊게 알게 되진 못했지만 그래도 책 한권을 거의 다 훑어 보았다는 것이 고무적인네요.

아직 한주차가 남았고 가장 중요한 챕터들도 남았으니 마지막까지 힘내보겠습니다.

이번 7주차에는 러스트의 핵심이라고 볼 수 있는 동시성에 대한 부분과, 아직 논란거리로 남아있는 러스트는 객체지향 언어인가에 대한 부분들을 다루어 보았습니다.

사실 조금 실망스러운 점은 동시성에 대한 내용이 이 책에서 너무 조금 다루어졌다는 것과, 객체지향에 대한 부분도 너무 짧게 넘어간 것 같은 부분입니다.

번역에 대한 부분도 조금 아쉽기는 하나, 이 책을 기반으로 이제 다음 러스트에 관한 책들을 읽을 때는 더 쉽게 이해할 수 있을 것 같습니다.

16장, 17장에 대한 간단한 정리

16. 겁 없는 동시성

러스트는 메모리 안전성과 데이터 경합 문제를 방지하면서 안전하게 동시성을 구현할 수 있는 강력한 도구를 제공합니다.

이번 글에서는 스레드를 이용한 코드의 동시 실행, 메시지 패싱을 통한 스레드 간 데이터 전송, 공유 상태 동시성, 그리고 Sync와 Send 트레이트를 사용한 확장 가능한 동시성에 대해 알아보겠습니다.

16.1. 스레드를 이용하여 코드를 동시에 실행하기

러스트에서 동시성을 구현하는 가장 기본적인 방법은 스레드를 사용하는 것입니다. std::thread 모듈을 통해 스레드를 생성하고 관리할 수 있습니다.

스레드 생성 및 실행

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

위 예제에서 thread::spawn을 사용하여 새로운 스레드를 생성하고 실행합니다.

메인 스레드와 생성된 스레드는 동시에 실행됩니다. handle.join()을 호출하여 생성된 스레드가 종료될 때까지 기다립니다.

스레드와 데이터 공유

스레드 간에 데이터를 공유하려면 move 키워드를 사용하여 데이터를 클로저로 이동시켜야 합니다.

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

위 예제에서 move 키워드를 사용하여 벡터 v를 클로저로 이동시킵니다. 이를 통해 생성된 스레드에서 v를 사용할 수 있습니다.

16.2. 메시지 패싱을 사용하여 스레드 간 데이터 전송하기

러스트에서는 메시지 패싱을 통해 스레드 간에 안전하게 데이터를 전송할 수 있습니다.

std::sync::mpsc 모듈을 사용하여 채널을 생성하고, 이를 통해 데이터를 주고받을 수 있습니다.

채널 생성 및 메시지 전송

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

위 예제에서 mpsc::channel을 사용하여 송신자(tx)와 수신자(rx)를 생성합니다. 생성된 스레드는 송신자를 통해 메시지를 전송하고, 메인 스레드는 수신자를 통해 메시지를 수신합니다.

다중 송신자

채널에는 여러 개의 송신자를 연결할 수 있습니다. 이를 통해 여러 스레드에서 데이터를 전송할 수 있습니다.

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    for i in 0..5 {
        let tx = tx.clone();
        thread::spawn(move || {
            let val = format!("hi number {}", i);
            tx.send(val).unwrap();
            thread::sleep(Duration::from_millis(100));
        });
    }

    for received in rx {
        println!("Got: {}", received);
    }
}

위 예제에서 tx.clone()을 사용하여 여러 송신자를 생성하고, 각 송신자는 개별 스레드에서 메시지를 전송합니다. 수신자는 모든 메시지를 수신하고 출력합니다.

16.3. 공유 상태 동시성

러스트에서는 여러 스레드 간에 데이터를 공유할 수 있도록 Arc와 Mutex를 제공합니다.

Arc는 원자적 참조 카운트(Atomic Reference Count) 스마트 포인터로, 데이터를 여러 소유자로 공유할 수 있게 합니다. Mutex는 데이터에 대한 상호 배제를 제공합니다.

`Arc`와 `Mutex` 사용 예제

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

위 예제에서 Arc::new를 사용하여 Mutex를 감싸고, 이를 통해 여러 스레드가 안전하게 데이터를 공유할 수 있습니다.

각 스레드는 counter.lock().unwrap()을 사용하여 Mutex를 잠그고, 공유 데이터를 안전하게 변경합니다.

16.4. `Sync`와 `Send` 트레이트를 이용한 확장 가능한 동시성

러스트의 동시성은 Sync와 Send 트레이트에 의해 관리됩니다.

Send 트레이트는 타입이 다른 스레드로 이동될 수 있음을 나타내고, Sync 트레이트는 타입이 여러 스레드에서 안전하게 접근될 수 있음을 나타냅니다.

`Send` 트레이트

Send 트레이트는 타입이 다른 스레드로 이동될 수 있음을 나타냅니다. 대부분의 기본 타입은 Send를 구현합니다.

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("{:?}", v);
    });

    handle.join().unwrap();
}

위 예제에서 벡터 v는 Send 트레이트를 구현하므로, thread::spawn을 통해 다른 스레드로 이동할 수 있습니다.

`Sync` 트레이트

Sync 트레이트는 타입이 여러 스레드에서 안전하게 접근될 수 있음을 나타냅니다. Arc<T>와 Mutex<T>는 Sync를 구현합니다.

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

위 예제에서 Arc<Mutex<T>>는 여러 스레드에서 안전하게 접근할 수 있습니다.

Mutex는 내부 데이터를 보호하며, Arc는 참조 카운트를 통해 여러 스레드가 안전하게 데이터를 공유할 수 있게 합니다.

결론

러스트는 메모리 안전성과 데이터 경합 문제를 방지하면서 안전하게 동시성을 구현할 수 있는 강력한 도구를 제공합니다.

스레드를 사용하여 코드를 동시에 실행하고, 메시지 패싱을 통해 스레드 간에 안전하게 데이터를 전송할 수 있습니다.

Arc와 Mutex를 사용하여 공유 상태 동시성을 구현할 수 있으며, Sync와 Send 트레이트를 통해 타입의 스레드 안전성을 관리할 수 있습니다.

이러한 기능을 잘 활용하면 러스트 프로그램을 더욱 효율적이고 안전하게 작성할 수 있습니다.

17. 러스트의 객체 지향 프로그래밍 기능들

러스트는 객체 지향 프로그래밍(OOP) 패러다임을 완전히 지원하지 않지만, 여러 객체 지향 프로그래밍 기능들을 제공합니다.

이를 통해 러스트에서 객체 지향 프로그래밍의 장점을 활용할 수 있습니다.

이번 글에서는 객체 지향 언어의 특성, 트레이트 객체를 사용하여 다양한 타입의 값을 허용하는 방법, 그리고 객체 지향 디자인 패턴을 구현하는 방법에 대해 알아보겠습니다.

17.1. 객체 지향 언어의 특성

객체 지향 프로그래밍은 데이터와 이를 조작하는 함수를 하나의 단위로 묶어 관리하는 프로그래밍 패러다임입니다. 객체 지향 언어의 주요 특성은 다음과 같습니다:

캡슐화(Encapsulation): 데이터와 함수를 하나의 객체로 묶어 외부로부터 보호합니다.
상속(Inheritance): 객체가 다른 객체의 속성과 메서드를 상속받아 재사용합니다.
다형성(Polymorphism): 동일한 인터페이스를 통해 다른 타입의 객체를 다룰 수 있습니다.

러스트는 상속을 지원하지 않지만, 캡슐화와 다형성은 트레이트와 구조체를 통해 구현할 수 있습니다.

17.2. 트레이트 객체를 사용하여 다른 타입의 값 허용하기

러스트에서 트레이트 객체는 다형성을 구현하는 데 사용됩니다. 트레이트 객체를 사용하면 여러 타입의 값을 동일한 인터페이스로 처리할 수 있습니다.

트레이트 객체 정의

먼저, 트레이트를 정의합니다.

trait Draw {
    fn draw(&self);
}

그 다음, 이 트레이트를 구현하는 구조체를 정의합니다.

struct Button {
    label: String,
}

impl Draw for Button {
    fn draw(&self) {
        println!("Drawing a button with label: {}", self.label);
    }
}

struct TextField {
    text: String,
}

impl Draw for TextField {
    fn draw(&self) {
        println!("Drawing a text field with text: {}", self.text);
    }
}

트레이트 객체 사용

Box<dyn Draw>를 사용하여 트레이트 객체를 생성할 수 있습니다. 이를 통해 다양한 타입의 값을 동일한 트레이트를 통해 다룰 수 있습니다.

fn main() {
    let button = Button { label: String::from("OK") };
    let text_field = TextField { text: String::from("Hello") };

    let components: Vec<Box<dyn Draw>> = vec![
        Box::new(button),
        Box::new(text_field),
    ];

    for component in components {
        component.draw();
    }
}

위 예제에서 Vec<Box<dyn Draw>>는 Draw 트레이트를 구현한 객체들의 벡터를 나타냅니다. 각각의 객체는 draw 메서드를 호출할 수 있습니다.

17.3. 객체 지향 디자인 패턴 구현하기

러스트에서는 여러 객체 지향 디자인 패턴을 트레이트와 구조체를 사용하여 구현할 수 있습니다.

이번 섹션에서는 전략 패턴(Strategy Pattern)과 옵저버 패턴(Observer Pattern)을 살펴보겠습니다.

전략 패턴

전략 패턴은 런타임에 알고리즘을 선택할 수 있게 하는 디자인 패턴입니다. 이를 통해 알고리즘을 클래스 외부에서 정의하고, 런타임에 이를 객체에 주입할 수 있습니다.

trait Strategy {
    fn execute(&self);
}

struct ConcreteStrategyA;
impl Strategy for ConcreteStrategyA {
    fn execute(&self) {
        println!("Executing strategy A");
    }
}

struct ConcreteStrategyB;
impl Strategy for ConcreteStrategyB {
    fn execute(&self) {
        println!("Executing strategy B");
    }
}

struct Context {
    strategy: Box<dyn Strategy>,
}

impl Context {
    fn new(strategy: Box<dyn Strategy>) -> Context {
        Context { strategy }
    }

    fn set_strategy(&mut self, strategy: Box<dyn Strategy>) {
        self.strategy = strategy;
    }

    fn execute_strategy(&self) {
        self.strategy.execute();
    }
}

fn main() {
    let strategy_a = Box::new(ConcreteStrategyA);
    let strategy_b = Box::new(ConcreteStrategyB);

    let mut context = Context::new(strategy_a);
    context.execute_strategy();

    context.set_strategy(strategy_b);
    context.execute_strategy();
}

위 예제에서 Context는 Strategy 트레이트를 구현한 객체를 받아서 사용합니다. set_strategy 메서드를 통해 런타임에 알고리즘을 변경할 수 있습니다.

옵저버 패턴

옵저버 패턴은 객체의 상태 변화를 관찰하고, 그 변화를 다른 객체에 통지하는 디자인 패턴입니다.

use std::cell::RefCell;
use std::rc::Rc;

trait Observer {
    fn update(&self, message: &str);
}

struct ConcreteObserver {
    name: String,
}

impl Observer for ConcreteObserver {
    fn update(&self, message: &str) {
        println!("{} received message: {}", self.name, message);
    }
}

struct Subject {
    observers: Vec<Rc<RefCell<dyn Observer>>>,
}

impl Subject {
    fn new() -> Subject {
        Subject {
            observers: Vec::new(),
        }
    }

    fn register_observer(&mut self, observer: Rc<RefCell<dyn Observer>>) {
        self.observers.push(observer);
    }

    fn notify_observers(&self, message: &str) {
        for observer in &self.observers {
            observer.borrow().update(message);
        }
    }
}

fn main() {
    let observer1 = Rc::new(RefCell::new(ConcreteObserver {
        name: String::from("Observer 1"),
    }));
    let observer2 = Rc::new(RefCell::new(ConcreteObserver {
        name: String::from("Observer 2"),
    }));

    let mut subject = Subject::new();
    subject.register_observer(observer1.clone());
    subject.register_observer(observer2.clone());

    subject.notify_observers("Hello, observers!");
}

위 예제에서 Subject는 옵저버들을 관리하며, 상태가 변경될 때 옵저버들에게 통지합니다.

Observer 트레이트를 구현한 객체는 update 메서드를 통해 메시지를 받습니다.

결론

러스트는 객체 지향 프로그래밍의 여러 특성을 트레이트와 구조체를 통해 구현할 수 있습니다.

트레이트 객체를 사용하여 다양한 타입의 값을 다룰 수 있으며, 여러 객체 지향 디자인 패턴을 구현할 수 있습니다.

이러한 기능을 잘 활용하면 러스트에서도 객체 지향 프로그래밍의 장점을 충분히 활용할 수 있습니다.

#학습 모임 기록

등록

DEVOTEE를 활성화 시키면
지금 작성한 댓글에 AI가 댓글을 달아줍니다.

익명

lambda 님의 최신 블로그

AI가 내 대신 쇼핑하는 세상, 무엇을 준비해야 하는가?

AI가 내 대신 쇼핑하는 세상: 기초부터 UCP까지 블록체인과 Web3의 기초부터 AI 경제의 미래까지, 구글의 AP2와 x402 프로토콜을 체계적으로 살펴봅니다. 구글이 최근 발표한 AP2, x402, UCP 등의 기술은 얼핏 복잡해 보이지만, 그 근본 원리를 이해하면 AI 경제의 미래가 명확하게 보입니다. 이 글에서는 블록체인의 기초 개념부터 시작하여, 최신 AI 결제 프로토콜인 AP2가 등장하게 된 배경과 작동 방식을 단계별로 기술하겠습니다. 1. 기초 다지기 - 블록체인과 Web3란 무엇인가 AI가 결제를 수행하기 위해서는 먼저 디지털 세상의 돈과 신뢰가 어떻게 작동하는지 이해할 필요가 있습니다. 이를 위한 핵심 기술이 바로 블록체인입니다. 1. 블록체인(...
NVIDIA Cosmos: WFM의 세 가지 핵심 모델과 피지컬 AI의 활용

서론 작년 CES에서 젠슨 황은 “피지컬 AI 시대”를 선언하면서, 디지털 트윈 플랫폼인 Omniverse와 함께 World Foundation Model(이하 WFM)인 NVIDIA Cosmos를 소개했습니다. 제가 처음 오픈소스로 공개된 Cosmos를 접했을 땐, 지금처럼 Predict / Transfer / Reason으로 잘 정리된 구조가 아니라 Autoregressive 계열 모델과 Diffusion 계열 모델이 제공되던 시기였습니다. Text-to-Video, Image-to-Video, Video-to-Video 같은 태스크를 각각 다른 파이프라인으로 처리했고, 튜토리얼과 작은 샘플 데이터셋을 이용하여 Autoregressive 모델을 파인튜닝해 보는...
NVIDIA issac sim으로 배우는 physical AI (5회차)

NVIDIA issac sim으로 배우는 physical AI 스터디가 어느덧 5회차가 되었습니다. 이번 모임은 엔비디아 엠베서더로 활동중이신 젯슨맘님을 모시고 세미나를 듣는 기회를 가졌습니다. 로봇쪽의 선구자로 활동중이신 선배님의 이야기들과, 노하우를 배울 수 있는 뜻깊은 시간이었습니다. 57살 동네 통장 아줌마의 변신 “인생 2막” 무식이 용감하다고 남들은 모두 스크레치를 배워서 방과후 교육을 지도 할 때, 아두이노를 이용해서 교육을 하기로 생각 하셨다고 합니다. 처음 아무것도 모르는 상황에서 주변 문화센터에 진행하는 수업을 등록하고 배우기 시작 나의 놀이터 : 디바이스랩 3D프린팅, 3D모델링 툴 배우기, 레이저 컷팅, 납 땜, **코딩 드론, 아두이노 RC...
NVIDIA Jetson Thor와 GR00T 모델을 활용한 로봇 시뮬레이션 테스트

지난 글에서 Jetson Thor의 기본적인 설명을 끝냈다면 이번엔 직접 실행해본 결과를 공유하는 내용을 작성해 보도록 하겠습니다. 지난 블로그 : https://devocean.sk.com/blog/techBoardDetail.do?ID=167723 Jetson Thor Setting 기본적으로 시작하기 앞서 필요한 준비물이 있습니다. 준비물 모니터 (HDMI) USB 키보드 USB 마우스 Jetson BSP 설치를 위한 USB Memory (32GB 이상 권장) Jetson BSP USB 연결 Jetson Thor는 Linux Host PC 없이 기존 PC용 리눅스를 설치 하는 방법과 동일하게 iso 이미지로 부트 USB를 만들어 설치가 가능 합니다. 부팅용 ...

DEVOTEE 추천 블로그

Openlab - 5차 Rust 스터디

5주차 스터디 소개 5주차 스터디는 6월 10일에 진행 했습니다. 러스트의 가장 어렵고, 핵심적인 내용인, ＂10장 제네릭 타입, 트레이트, 라이프타임＂ 에 대한 내용에 대해 공유 했고, 늘상 스터디를 진행하면서, 모이신 분들의 여러 경험과 다른 언어에 대한 이야기를 하면서 이해도를 높였는데 특히 이번 스터디를 진행 할 때 많은 심도 있는 이야기를 나눴던 것 같습니다. 스터디 진행의 중반 정도 달려온 것 같습니다. 개인 사정으로 빠지신 분들도 계시고 내용도 점점 어려워 지지만 모두 ＂중꺽마＂를 잊지 않기를 당부 했습니다. 이번 스터디는 책는 ＂9장 예외처리＂, ＂10장 제네릭 타입, 트레이트, 라이프타임＂에 대해 저와, 김유진님이 정리하여 발표해 주셨습니다. 9장...
Openlab - 8차 Rust 마지막 스터디

마지막 8주차 스터디는 7월 29일에 진행 했습니다. 원래 한 주 일찍 하려고 했던 스터디는 제가 코로나에 걸리는 바람에 한 주 미뤄지게되어, 7월 29일에 진행 했습니다. 마지막 챕터는 러스트의 고급 기능들 입니다. 러스트의 가장 장점은 안전성인것에 반해, 고급기능에 unsafe가 있다는건 조금 이상하긴 하지만 컴파일러가 모든 경우의 수를 다 계산하여 검증 해 줄 수 없기 때문에, 어느 정도는 개발자에게 맡기는 방법도 사용하는 것 같습니다. 고급기능을 마지막으로 러스트 프로그래밍 공식가이드 2판 책으로 시작한 스터디는 마무리 했습니다. 공식가이드인 만큼 처음 러스트를 접하는 사람들을 위한 것인지 쉽게 쓰여져 있긴 했지만, 그만큼 조금 더 설명 해야 했을 부분을 ...
[데보션영과 함께하는 책읽기-21편] Effective Java 도서스터디 후기

안녕하세요. 데보션 영 3기 Effective Java 도서스터디팀 입니다. 저희 팀은 ‘이펙티브 자바’라는 책을 선정해서 스터디를 진행했습니다. 자바 개발자에게는 바이블과도 같다고 불리는 책인지라 다들 한번쯤 꼭 읽어보고 싶은 마음에 선택했다고 합니다. 전원 백엔드 개발자로 이루어져 있어서 더더욱 재미있게 읽을 수 있었던 책이었습니다. 🎯 스터디 진행 방식 스터디의 경우 책이 굉장히 길기 때문에.. 다양한 방식으로 긴 기간동안 흥미를 잃지 않고 진행해보고자 노력했습니다. 시간이 다 되는 경우에는 강남역 할리스에 모여서 같이 스터디를 진행했습니다. 스터디 인원도 많은 편이라 매번 만나기는 쉽지 않았는데요. 그럴 때는 온라인으로도 적극적으로 모여서 같이 스터디를 ...
AI 서비스 개발을 위한 대규모 시스템 설계 스터디 (5회차 모임)

안녕하세요, AI 서비스 개발을 위한 대규모 시스템 설계 스터디 호스트 송의석입니다. 9월 23일에는 저희 스터디의 다섯 번째 모임을 진행하였습니다. 모임 이전에 각자 『데이터 중심 애플리케이션 설계』 도서의 챕터 7, 8을 읽어오고, 모임에서는 박영훈님과 오종해님이 한 챕터씩 맡아 발표를 진행해주셨습니다. 7장 트랜잭션 7장은 영훈님이 발표를 맡아주셨습니다. 트랜잭션은 데이터베이스에서 여러 연산을 하나의 논리적인 단위로 묶어서, 원자성·일관성·격리성·지속성, 흔히 말하는 ACID 특성을 만족하도록 보장하는 개념이라고 하셨습니다. 책에서는 실제 시스템에서 사용하는 다양한 고립 수준과 동시성 제어 기법들을 자세히 다뤘습니다. 직렬성 수준이 가장 강력하지만 성능 손해...

목록으로

DEVOCEAN

로그인 선택

미리보기

커뮤니티

글 등록

임시저장함

데보션 블로그 게재 요청