동기식 파일 처리

use std::fs::File;
use std::io::{self, Read, Write};

fn main() -> io::Result<()> {
    // 파일 읽기
    let mut file = File::open("input.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

    // 파일 쓰기
    let mut file = File::create("output.txt")?;
    file.write_all(contents.as_bytes())?;
    Ok(())
}

큰 파일을 다룰 때에는 BufReader를 사용하면 메모리를 효율적으로 사용할 수 있습니다.

use std::fs::File;
use std::io::{self, BufReader};

fn main() -> io::Result<()> {
    let file = File::open("large_file.txt")?;
    let reader = BufReader::new(file);

    for line in reader.lines() {
        println!("{}", line?);
    }
    Ok(())
}

비동기식 파일 처리

Tokio를 사용하면 비동기로 파일을 처리할 수 있습니다. I/O 작업 중 다른 작업을 수행할 수 있어서 웹 서버나 동시에 여러 파일을 처리해야 하는 경우에 유용합니다.

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

async fn handle_file() -> io::Result<()> {
    let mut file = File::open("input.txt").await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;

    let mut file = File::create("output.txt").await?;
    file.write_all(contents.as_bytes()).await?;
    Ok(())
}

여러 파일을 동시에 처리할 수도 있습니다.

use tokio::fs;
use futures::future::join_all;

async fn process_files(files: Vec<String>) -> io::Result<()> {
    let handles: Vec<_> = files.into_iter()
        .map(|file| tokio::spawn(async move {
            let contents = fs::read_to_string(file).await?;
            // 파일 처리 로직
            Ok::<(), io::Error>(())
        }))
        .collect();

    join_all(handles).await?;
    Ok(())
}

동기식 vs 비동기식

동기식은 작업이 완료될 때까지 스레드가 블로킹되지만 구현이 단순합니다.
비동기식은 I/O 대기 중 다른 작업을 수행할 수 있지만 tokio 같은 런타임이 필요합니다.

CLI 도구나 설정 파일 로딩처럼 단순한 경우에는 동기식이 적합하고, 웹 서버나 대량 파일 처리에는 비동기식이 적합합니다.

성능 최적화

버퍼 크기를 조정하거나 메모리 매핑을 사용할 수 있습니다.

use std::io::BufReader;

let file = File::open("large_file.txt")?;
let reader = BufReader::with_capacity(64 * 1024, file); // 64KB 버퍼

use memmap2::MmapOptions;

let file = File::open("large_file.txt")?;
let mmap = unsafe { MmapOptions::new().map(&file)? };