Rust 檔案系統處理與多執行緒應用

– 11 分鐘閱讀

Rust 的嚴謹型別系統和所有權機制，讓它在系統程式設計領域中，得以兼顧效能和安全性。本文將示範如何運用 Rust 處理檔案系統，讀取特定目錄下的 Markdown 檔案，並利用多執行緒技術提升處理效率。同時，我們也會探討智慧指標如何有效管理記憶體，以及通道線上程間的資料傳遞機制。這些技術的整合，能讓開發者更有效率地處理大量檔案，並建構更穩健的應用程式。

檔案系統和Markdown檔案處理

在這個章節中，我們將探討如何處理檔案系統和Markdown檔案，以便提取必要的資訊並建立JSON檔案。

讀取目錄和提取Markdown檔案

首先，我們需要讀取目錄中的檔案並提取Markdown檔案。為此，我們可以使用std::fs::read_dir()函式，該函式傳回一個ReadDir物件，該物件包含目錄中的所有檔案。

use std::fs::read_dir;

pub fn extract(path: &str) -> OrderResult<Self> {
    let mut md_content = Vec::new();
    for entry in read_dir(path).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        println!("Processing file: {}", path.display());
        // ...
    }
}

檢查檔案是否為Markdown檔案

接下來，我們需要檢查每個檔案是否為Markdown檔案。為此，我們可以使用path.extension()函式，該函式傳回檔案的副檔名。如果副檔名為`".md"，則我們可以將檔案視為Markdown檔案。

if let Some(ext) = path.extension() {
    if ext == "md" {
        // ...
    }
}

讀取Markdown檔案內容

如果檔案是Markdown檔案，我們需要讀取其內容。為此，我們可以使用std::fs::read_to_string()函式，該函式傳回檔案的內容。

let content = read_to_string(path).unwrap();

建立Markdown結構

現在，我們需要建立一個Markdown結構來儲存檔案的名稱和內容。為此，我們可以定義一個Markdown結構，並實作其new()函式。

impl Markdown {
    pub fn new(name: String, content: String) -> Self {
        Self { name, content }
    }
}

推入Markdown值

最後，我們需要將Markdown值推入md_content向量中。

md_content.push(Markdown::new(path.file_name().unwrap().to_string_lossy().into_owned(), content));

完整的extract()函式

以下是完整的extract()函式：

pub fn extract(path: &str) -> OrderResult<Self> {
    let mut md_content = Vec::new();
    for entry in read_dir(path).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        println!("Processing file: {}", path.display());
        if let Some(ext) = path.extension() {
            if ext == "md" {
                let content = read_to_string(path).unwrap();
                md_content.push(Markdown::new(path.file_name().unwrap().to_string_lossy().into_owned(), content));
            }
        }
    }
    Ok(Order { md_content })
}

圖表翻譯：

  graph LR
    A[讀取目錄] --> B[提取Markdown檔案]
    B --> C[檢查檔案是否為Markdown檔案]
    C --> D[讀取Markdown檔案內容]
    D --> E[建立Markdown結構]
    E --> F[推入Markdown值]
    F --> G[傳回Order結構]

內容解密：

以上的程式碼實作了讀取目錄、提取Markdown檔案、檢查檔案是否為Markdown檔案、讀取Markdown檔案內容、建立Markdown結構和推入Markdown值等功能。最終，程式碼傳回一個Order結構，該結構包含了所有Markdown檔案的名稱和內容。

Markdown檔案讀取與處理

在這個章節中，我們將實作一個功能，從指定目錄中讀取Markdown檔案，提取檔案名稱和內容，然後將這些資訊儲存在一個結構體中。

目錄讀取與檔案過濾

首先，我們需要讀取指定目錄中的所有檔案和目錄。這可以使用std::fs::read_dir()函式實作。然後，我們需要過濾出Markdown檔案。

// 讀取目錄中的所有檔案和目錄
for entry in read_dir(path)? {
    // 處理錯誤，確保entry是DirEntry
    let entry = entry?;
    // 通知使用者正在處理此檔案
    println!("Processing {}", entry.path().display());
    
    // 取得檔案路徑
    let path = entry.path();
    // 取得檔案的副檔名
    let extension = path.extension().unwrap().to_str();
    
    // 使用match陳述式過濾Markdown檔案
    match extension {
        Some("md") => {
            // 提取檔案名稱
            let filename = path.file_name().unwrap().to_str().unwrap().replace(".md", "");
            // 讀取檔案內容
            let content = read_to_string(&path)?;
            // 建立新的Markdown結構體並新增到md_content中
            md_content.push(Markdown::new(filename, content));
        }
        _ => continue,
    }
}

Markdown結構體定義

在上面的程式碼中，我們使用了Markdown結構體來儲存Markdown檔案的名稱和內容。這個結構體可以定義如下：

struct Markdown {
    filename: String,
    content: String,
}

impl Markdown {
    fn new(filename: &str, content: String) -> Self {
        Markdown {
            filename: filename.to_string(),
            content,
        }
    }
}

CLI命令實作

現在，我們可以在src/bin/app.rs中新增新的create命令。首先，需要在CLI列舉中新增新的變體：

#[derive(StructOpt)]
pub enum CLI {
    // ...
    #[structopt(about = "Create an order from a directory of markdown files")]
    Create {
        // 目錄路徑
        directory: String,
        // 輸出路徑
        output: String,
    }
}

然後，可以實作create命令的邏輯：

match cli {
    // ...
    CLI::Create { directory, output } => {
        // 讀取目錄中的Markdown檔案
        let md_content = read_markdown_files(&directory)?;
        // 將Markdown內容寫入JSON檔案
        write_json_file(&output, &md_content)?;
    }
}

JSON檔案寫入

最後，需要實作將Markdown內容寫入JSON檔案的功能：

fn write_json_file(path: &str, md_content: &Vec<Markdown>) -> Result<(), std::io::Error> {
    let json = serde_json::to_string(md_content)?;
    std::fs::write(path, json)?;
    Ok(())
}

這樣就完成了從目錄中讀取Markdown檔案、提取檔案名稱和內容、然後將這些資訊儲存在JSON檔案中的功能。

建立命令列工具的建立功能

我們已經增加了一個新的變體到命令列工具中，現在需要在 main 函式中的 match 陳述式中新增一個新的案例。這個案例將使用 Order::extract() 方法從指定的目錄路徑中提取訂單，然後使用 create_json_file() 方法建立一個新的 JSON 檔案到指定的輸出路徑。

match cli {
    // ...
    CLI::Create { directory, output } => {
        // 從目錄路徑中提取訂單
        let order = Order::extract(&directory)?;
        // 建立一個新的 JSON 檔案
        order.create_json_file(&output)?;
    }
}

測試應用程式

為了測試新的應用程式，建立一個名為 markdown_test 的目錄在專案根目錄下，然後新增以下檔案及其內容：

markdown_test/01.md：

# 這是第一個檔案
> 這是一個帶有程式碼的參照

> ```
> let example = Example::new();
> ```

markdown_test/02.md：


## 這是第二個訊息
我們可以使用 **粗體** 或 *斜體*。這是一個連結到

### 這是第三個訊息

我們非常酷

markdown_test/03.md：


### 這是第三個訊息

我們可以使用 `單行程式碼` 或多行程式碼

```rust
fn seventy() -> i32 {
    let x = 50;
    x += 20;
    return x;
}


## 執行建立命令
現在，讓我們使用 `create` 命令建立 `orders.json` 檔案並生成 zip 檔案：

```bash
# 在另一個標籤頁中
$ cargo run --bin server

圖表翻譯：

  graph LR
    A[建立命令] --> B[提取訂單]
    B --> C[建立 JSON 檔案]
    C --> D[生成 zip 檔案]

圖表翻譯：

這個圖表描述了建立命令的執行流程。首先，建立命令被執行，然後從指定的目錄路徑中提取訂單。接下來，建立一個新的 JSON 檔案到指定的輸出路徑。最後，生成 zip 檔案。

並發程式設計在 Rust 中的應用

Rust 不僅能夠保證程式的記憶體安全，也能夠確保執行緒安全。這使得開發者可以毫無顧慮地執行程式，無需擔心資料存取不一致、死鎖等常見的並發程式錯誤。

並發程式的基本概念

並發程式設計涉及到多個執行緒的執行，需要考慮到資料的分享和存取。Rust 的標準函式庫提供了執行緒的支援，同時也引入了新的作用域執行緒（scoped threads）特性。

智慧指標的重要性

智慧指標（smart pointers）是 Rust 中的一種重要特性，提供了堆積疊組態型別的支援。它們可以用於安全地跨執行緒傳遞值。

並發程式設計的實作

並發程式設計的實作涉及到執行緒的建立和管理。Rust 的標準函式庫提供了 std::thread 模組，用於建立和管理執行緒。

執行緒的建立

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from a new thread!");
    });
    handle.join().unwrap();
}

值的傳遞

並發程式設計中，需要傳遞值給不同的執行緒。Rust 提供了多種方式來實作值的傳遞，包括通道（channels）、鎖定型別（locking types）和單執行緒存取（single-threaded access）。

通道

通道是 Rust 中的一種同步型別，用於線上程之間傳遞值。

use std::thread;
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();
    let handle = thread::spawn(move || {
        let msg = "Hello from a new thread!";
        tx.send(msg).unwrap();
    });
    let msg = rx.recv().unwrap();
    println!("Received: {}", msg);
    handle.join().unwrap();
}
鎖定型別

鎖定型別是 Rust 中的一種同步型別，用於保護分享資料。

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

單執行緒存取

單執行緒存取是 Rust 中的一種同步型別，用於保護分享資料。

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter_clone.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

多執行緒讀取

多執行緒讀取是 Rust 中的一種同步型別，用於保護分享資料。

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

fn main() {
    let counter = Arc::new(RwLock::new(0));
    let mut handles = vec![];
    for _ in 0..10 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let num = counter_clone.read().unwrap();
            println!("Read: {}", *num);
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.read().unwrap());
}

圖表翻譯：

此圖示展示了 Rust 中的並發程式設計，包括執行緒的建立、值的傳遞和鎖定型別的使用。圖中展示了使用通道、鎖定型別和單執行緒存取的例子。

  flowchart TD
    A[執行緒建立] --> B[值傳遞]
    B --> C[鎖定型別]
    C --> D[單執行緒存取]
    D --> E[多執行緒讀取]

內容解密：

此章節介紹了 Rust 中的並發程式設計，包括執行緒的建立、值的傳遞和鎖定型別的使用。並發程式設計是 Rust 中的一個重要特性，允許開發者建立安全且高效的並發程式。

智慧指標（Smart Pointers）在 Rust 中的應用

Rust 中的智慧指標（Smart Pointers）為開發者提供了一種簡單的方式來建立堆積積（Heap）分配的繫結。在本章中，我們將探討各種智慧指標的應用。需要注意的是，所有這些智慧指標都擁有其內部的值。

使用 Box 來建立堆積積分配的值

建立堆積積分配的值最簡單的方式是使用 Box 型別。這會為內部的值分配堆積積記憶體。這種方法可以用於連結串列（Linked List）或傳回未知大小的值。

如果我們試圖在沒有使用 Box 的情況下建立自己的連結串列，我們將會遇到遞迴問題，如下所示：

type Link = Option<Node>;

struct Node {
    value: u32,
    next: Link,
    prev: Link,
}

struct LinkedList {
    length: usize,
    head: Link,
    tail: Link,
}

編譯器會報錯，因為遞迴型別 Node 的大小是無限的。為瞭解決這個問題，我們可以按照編譯器的建議，使用 Box 來建立 Link 型別，如下所示：

type Link = Option<Box<Node>>;

struct Node {
    value: u32,
    next: Link,
    prev: Link,
}

struct LinkedList {
    length: usize,
    head: Link,
    tail: Link,
}

這樣，我們就可以遞迴地存取和使用節點。

使用 Box 型別

要建立一個新的 Box 值，我們可以使用 Box::new() 函式，如下所示：

fn main() {
    let boxed = Box::new(8);
    println!("{}", *boxed);
}

這會為內部的值分配堆積積記憶體，並且擁有該值。要存取內部的值，我們需要使用原始指標 * 來解參照。

參照計數（Reference Counting）使用 Rc 和 Arc

如果我們想要多個擁有者分享同一個值，我們需要使用參照計數來保證記憶體安全。 Rc 和 Arc 都是參照計數的實作，但 Arc 是一個原子參照計數，它實作了 Sync 特徵，因此可以用於多執行緒的工作負載。

以下是使用 Arc 的例子：

use std::sync::Arc;

fn main() {
    let mut val = Arc::new(90);
    *Arc::make_mut(&mut val) += 10;

    let mut other_val = val.clone();
    *Arc::make_mut(&mut other_val) += 100;

    println!("Other val: {}", *other_val);
    println!("Val: {}", *val);
}

這個例子展示瞭如何使用 Arc 來建立多個擁有者，並且如何使用 make_mut 方法來修改內部的值。

圖表翻譯：

  graph LR
    A[Box] --> B[堆積積分配]
    B --> C[值]
    C --> D[解參照]
    D --> E[存取值]
    E --> F[參照計數]
    F --> G[Rc]
    G --> H[Arc]
    H --> I[多執行緒]
    I --> J[Sync]
    J --> K[安全]

這個圖表展示了 Box、Rc 和 Arc 之間的關係，以及如何使用參照計數來保證記憶體安全。

內部可變性與並發性

在 Rust 中，內部可變性是指在不違反借用規則的情況下，仍能夠修改某個值的內容。這可以透過使用 Cell 或 RefCell 來實作。

使用 Cell

Cell 是一個可以內部修改的型別，它需要內部值實作 Copy 特徵。以下是一個使用 Cell 的例子：

use std::cell::Cell;

#[derive(Debug, Copy, Clone)]
struct Something {
    normal: i32,
    cool: Cell<i32>,
}

fn main() {
    let smth = Something {
        normal: 32,
        cool: Cell::new(90),
    };

    // 可以修改 cool 的值
    smth.cool.set(100);

    println!("{:?}", smth);
}

在這個例子中，smth 是一個不可變的繫結，但是我們仍然可以修改 cool 的值。

使用 RefCell

RefCell 是另一個可以內部修改的型別，它不需要內部值實作 Copy 特徵。相反，它使用執行時鎖定來保證記憶體安全。以下是一個使用 RefCell 的例子：

use std::cell::RefCell;

#[derive(Debug)]
struct Something {
    normal: i32,
    cool: RefCell<i32>,
}

fn main() {
    let smth = Something {
        normal: 32,
        cool: RefCell::new(90),
    };

    // 可以修改 cool 的值
    *smth.cool.borrow_mut() = 100;

    println!("{:?}", smth);
}

在這個例子中，smth 是一個不可變的繫結，但是我們仍然可以修改 cool 的值。

並發性

並發性是指多個程式可以同時在不同的執行緒上執行。Rust 保證執行緒安全透過兩個特徵：Send 和 Sync。如果一個型別實作了 Send，它可以安全地傳送到另一個執行緒。如果一個型別實作了 Sync，它可以安全地在多個執行緒之間分享。

使用執行緒

Rust 的標準函式庫提供了 std::thread 模組來建立和管理執行緒。以下是一個使用執行緒的例子：

use std::thread;

fn main() {
    let mut handles = Vec::new();

    for i in 0..10 {
        handles.push(thread::spawn(move || {
            println!("{}", i);
        }));
    }

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

在這個例子中，我們建立了 10 個執行緒，每個執行緒都會列印預出一個數字。

使用向量

如果我們想要列印預出一個向量的元素，可以使用以下的例子：

use std::thread;

fn main() {
    let elements = vec![1, 2, 3, 4, 5, 6, 7];
    let mut handles = Vec::new();

    for i in 0..elements.len() {
        handles.push(thread::spawn(move || {
            println!("{}", elements[i]);
        }));
    }

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

在這個例子中，我們建立了 7 個執行緒，每個執行緒都會列印預出向量中的一個元素。

圖表翻譯：

  graph LR
    A[建立執行緒] --> B[列印數字]
    B --> C[等待執行緒完成]
    C --> D[列印向量元素]
    D --> E[等待執行緒完成]
    E --> F[完成]

這個圖表展示了建立執行緒、列印數字、等待執行緒完成、列印向量元素、等待執行緒完成的過程。

Rust 中的多執行緒和通道

Rust 是一種系統程式語言，提供了多種方式來實作多執行緒和通道。以下是 Rust 中多執行緒和通道的基本概念和使用方法。

從底層實作到高階應用的全面檢視顯示，Rust 的檔案系統操作、Markdown 檔案處理以及平行處理能力，展現了其作為系統程式語言的強大之處。透過多維度效能指標的實測分析，Rust 的所有權系統和借用檢查器有效地防止了資料競爭和其他常見的平行程式設計錯誤，保障了記憶體安全和執行緒安全。然而，Rust 的學習曲線較陡峭，對於不熟悉其概念的開發者來說，需要投入更多時間和精力來掌握。整合此技術至現有系統的策略和價值在於其高效能和安全性，尤其適用於對效能和穩定性有高度要求的系統。對於重視長期穩定性的企業，採取漸進式整合策略將帶來最佳平衡。接下來的 2-3 年，將是 Rust 在更多領域展現其優勢的關鍵視窗期，隨著社群和生態系統的持續發展，我們預見其應用門檻將逐步降低。玄貓認為，Rust 已展現足夠成熟度，適合關注效能和安全的核心繫統採用。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。