Rust是一種強類型、高性能的系統編程語言，其官方文檔中強調了Rust的標準庫具有良好的并發編程支持。Thread是Rust中的一種并發編程方式，本文將介紹Rust中thread的相關概念、方法和字段、常見用法以及多線程的一些實踐經驗。由淺入深帶你零基礎玩轉Rust的多線程編程。

線程的基本概念和使用方法

Thread是Rust中并發編程的一種基本方式。Rust中的Thread使用標準庫中的std::thread::Thread結構體表示。我們可以通過下面的代碼來創建一個Thread：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // 子線程執行的代碼
    });
}

其中的||表示閉包，該閉包中的代碼將在子線程中執行。調用thread::spawn方法會返回一個Result，該Result包含一個智能指針，該智能指針擁有對線程的所有權，如果線程執行成功則返回Ok，否則返回Err。通過這個智能指針我們可以管理線程的生命周期和操作線程。

當線程中的代碼執行完畢時，我們可以使用以下代碼將線程加入主線程：

handle.join().expect("執行失敗");

Thread也支持通過std::thread::Builder結構體進行創建，Builder提供了一些線程的配置項，如線程名字、線程優先級、棧大小等。

use std::thread;

fn main() {
    let builder = thread::Builder::new().name("my_thread".into());
    let handle = builder.spawn(|| {
        // 子線程執行的代碼
    });
}

線程的字段和方法

Thread結構體中提供了一些有用的字段和方法。

線程名稱

Rust中的Thread對象有一個名稱屬性，可以通過thread::current()函數獲取當前線程的名稱，也可以通過std::thread::Builder結構體設置線程的名稱。

use std::thread;

fn main() {
    let thr0 = thread::current();
    let thread_name = thr0.name().unwrap_or("unknown");
    println!("當前線程的名稱：{}", thread_name);
    
    let builder = thread::Builder::new().name("my_thread".into());
    let handle = builder.spawn(move || {
        let thr = thread::current();
        let name = thr.name().unwrap_or("unknown");
        println!("當前線程的名稱：{}", name);
    });
    handle.expect("執行失敗").join().unwrap();
}
//  輸出結果：
// 當前線程的名稱：main
// 當前線程的名稱：my_thread

線程id

Rust中的Thread對象還有一個id屬性，可以通過thread::current()函數獲取當前線程的id，也可以通過std::thread::Builder結構體設置線程的id。

use std::thread;

fn main() {
    let thread_id = thread::current().id();
    println!("當前線程的id：{:?}", thread_id);
    
    let builder = thread::Builder::new().name("my_thread".into());
    let handle = builder.spawn(|| {
        let id = thread::current().id();
        println!("當前線程的id：{:?}", id);
    });
    handle.expect("執行失敗").join().unwrap();
}
//  輸出結果：
// 當前線程的id：ThreadId(1)
// 當前線程的id：ThreadId(2)

線程休眠

Rust中Thread對象提供了一個sleep方法，用于讓線程休眠指定時間。

use std::{thread, time};

fn main() {
    println!("線程休眠前：{:?}", time::Instant::now());
    thread::sleep(time::Duration::from_secs(2));
    println!("線程休眠后：{:?}", time::Instant::now());
}
//  輸出結果：
// 線程休眠前：Instant { tv_sec: 9667960, tv_nsec: 471430161 }
// 線程休眠后：Instant { tv_sec: 9667962, tv_nsec: 471515229 }

線程狀態

Rust中Thread對象表示的是系統中的一個線程，可以通過thread::JoinHandle結構體的is_finalized()和thread::Thread的panicking()方法來查看線程是否結束和是否因panic而結束。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // TODO: 執行耗費時間的任務
    });
    while !handle.is_finished() {
        thread::sleep_ms(100);
    }
    if thread::panicking() {
        println!("線程因panic而結束");
    } else {
        println!("線程正常結束");
    }
}

常用用法和示例

單線程執行

我們可以使用Thread開啟一個單線程，并在該線程中執行我們的代碼。當該線程執行完畢后，我們通過JoinHandle.join()方法將該線程加入主線程。

use std::thread;

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

多線程執行

我們可以使用多個Thread對象并行地執行任務，實現多線程編程。

use std::thread;

fn main() {
    let handle1 = thread::spawn(|| {
        for i in 0..5 {
            println!("Thread1: {}", i);
        }
    });
    let handle2 = thread::spawn(|| {
        for i in 0..5 {
            println!("Thread2: {}", i);
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

線程間通信

Rust中線程間通信可以通過channel實現。在以下例子中，我們開啟兩個線程，一個線程向channel發送數據，另一個線程從channel接收數據。兩個線程可以通過channel實現數據共享和交換。

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

fn main() {
    let (tx, rx) = mpsc::channel();
    let handle1 = thread::spawn(move || {
        tx.send("Hello Thread!".to_string()).unwrap();
    });
    let handle2 = thread::spawn(move || {
        let msg = rx.recv().unwrap();
        println!("{}", msg);
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

進階用法：多線程協作和鎖

多線程協作

當線程之間需要協作執行任務時，我們可以通過Rust中提供的互斥鎖Mutex和讀寫鎖RwLock來實現。

以下是一個簡單的例子，在這個例子中我們開啟兩個線程，一個線程向共享變量加1，另一個線程向共享變量減1。由于有兩個線程同時修改共享變量，我們需要使用Mutex來進行加鎖和解鎖操作。

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

fn main() {
    let shared_count = Arc::new(Mutex::new(0));
    let thread1 = shared_count.clone();
    let handle1 = thread::spawn(move || {
        for _ in 0..10 {
            let mut count = thread1.lock().unwrap();
            *count += 1;
        }
    });
    let thread2 = shared_count.clone();
    let handle2 = thread::spawn(move || {
        for _ in 0..10 {
            let mut count = thread2.lock().unwrap();
            *count -= 1;
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("shared_count: {:?}", *shared_count.lock().unwrap());
}
//    輸出結果：
//  shared_count: 0

鎖

在多線程編程中，鎖是一種常見的同步機制，它用于保護共享數據不受到并發訪問的影響。Rust標準庫中提供了鎖的實現Mutex、RwLock、Barrier、Condvar等等。

Mutex

Mutex是Rust中最基本的鎖機制，它提供了互斥訪問的機制。當多個線程同時對一個共享資源進行訪問時，Mutex會對該資源進行加鎖，當一個線程訪問該資源時，其他線程無法訪問該資源，直到該線程解鎖該資源。

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

fn main() {
    let shared_data = Arc::new(Mutex::new(0));
    let thread1 = shared_data.clone();
    let handle1 = thread::spawn(move || {
        for _ in 0..10 {
            let mut data = thread1.lock().unwrap();
            *data += 1;
        }
    });
    let thread2 = shared_data.clone();
    let handle2 = thread::spawn(move || {
        for _ in 0..10 {
            let mut data = thread2.lock().unwrap();
            *data -= 1;
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("shared_data: {:?}", *shared_data.lock().unwrap());
}
//    輸出結果：
//  shared_data: 0

RwLock

RwLock是一種讀寫鎖，它提供了兩種訪問方式：讀取訪問和寫入訪問，當同時有多個讀操作時，RwLock會共享鎖，允許多個線程同時訪問該數據，當進行寫操作時，RwLock會對該數據進行排它鎖，只允許一個線程進行訪問。

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

fn main() {
    let shared_data = Arc::new(RwLock::new(0));
    let thread1 = shared_data.clone();
    let handle1 = thread::spawn(move || {
        for _ in 0..10 {
            let mut data = thread1.write().unwrap();
            *data += 1;
        }
    });
    let thread2 = shared_data.clone();
    let handle2 = thread::spawn(move || {
        for _ in 0..10 {
            let data = thread2.read().unwrap();
            println!("data: {:?}", *data);
        }
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
    println!("shared_data: {:?}", *shared_data.read().unwrap());
}
//    輸出結果：
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// data: 10
// shared_data: 10

RwLock還提供了一個try_read()方法，可以進行非阻塞式的讀操作。

Barrier

Barrier是一種同步機制，它提供了一個點，當多個線程只有在該點處到達才能繼續執行。Barrier有一個計數器，當計數器到達值N時，所有在該Barrier處等待的線程可以繼續執行。

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

fn main() {
    let barrier = Arc::new(Barrier::new(3));
    let thread1 = barrier.clone();
    let handle1 = thread::spawn(move || {
        println!("Thread1 step1.");
        thread1.wait();
        println!("Thread1 step2.");
    });
    let thread2 = barrier.clone();
    let handle2 = thread::spawn(move || {
        println!("Thread2 step1.");
        thread2.wait();
        println!("Thread2 step2.");
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}
//    輸出結果：
// Thread1 step1.
// Thread2 step1.
// ERROR Timeout

最佳實踐：安全地使用Thread

在使用Thread進行多線程編程時，為了保證線程安全，我們需要注意以下幾點：

• ? 在多線程程序中避免使用靜態變量，單例模式和全局變量，這些變量可能被多個線程同時訪問。
• ? 在多線程編程中，一定要避免使用裸指針和內存共享，這種方式可能導致數據競爭和未定義行為。
• ? 使用Rust的鎖機制Mutex和RwLock等，保證共享數據的線程安全性。
• ? 編寫多線程程序時，應該考慮線程池的設計，防止創建過多的線程帶來的資源錯亂和性能損失。
• ? 多線程程序的并發度一定要注意控制，過高的并發度反而會導致性能下降。

以上都是在使用Thread時應該注意的一些安全問題，遵循這些原則可以提高多線程程序的可維護性和安全性。

總結

本章節通過代碼示例深入的探討了Rust中thread的線程的基本概念，線程的字段和方法，常用用法和示例，多線程協作和鎖以及thread最佳實踐經驗。