Rust的多線程編程概念和使用方法

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

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

Thread是Rust中并發(fā)編程的一種基本方式。Rust中的Thread使用標準庫中的std::thread::Thread結(jié)構(gòu)體表示。我們可以通過下面的代碼來創(chuàng)建一個Thread：

use std::thread;

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

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

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

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

Thread也支持通過std::thread::Builder結(jié)構(gòu)體進行創(chuàng)建，Builder提供了一些線程的配置項，如線程名字、線程優(yōu)先級、棧大小等。

use std::thread;

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

線程的字段和方法

Thread結(jié)構(gòu)體中提供了一些有用的字段和方法。

線程名稱

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

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("執(zhí)行失敗").join().unwrap();
}
//  輸出結(jié)果：
// 當前線程的名稱：main
// 當前線程的名稱：my_thread

線程id

Rust中的Thread對象還有一個id屬性，可以通過thread::current()函數(shù)獲取當前線程的id，也可以通過std::thread::Builder結(jié)構(gòu)體設(shè)置線程的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("執(zhí)行失敗").join().unwrap();
}
//  輸出結(jié)果：
// 當前線程的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());
}
//  輸出結(jié)果：
// 線程休眠前：Instant { tv_sec: 9667960, tv_nsec: 471430161 }
// 線程休眠后：Instant { tv_sec: 9667962, tv_nsec: 471515229 }

線程狀態(tài)

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

use std::thread;

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

常用用法和示例

單線程執(zhí)行

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

use std::thread;

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

多線程執(zhí)行

我們可以使用多個Thread對象并行地執(zhí)行任務(wù)，實現(xiàn)多線程編程。

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實現(xiàn)。在以下例子中，我們開啟兩個線程，一個線程向channel發(fā)送數(shù)據(jù)，另一個線程從channel接收數(shù)據(jù)。兩個線程可以通過channel實現(xiàn)數(shù)據(jù)共享和交換。

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();
}

進階用法：多線程協(xié)作和鎖

多線程協(xié)作

當線程之間需要協(xié)作執(zhí)行任務(wù)時，我們可以通過Rust中提供的互斥鎖Mutex和讀寫鎖RwLock來實現(xiàn)。

以下是一個簡單的例子，在這個例子中我們開啟兩個線程，一個線程向共享變量加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());
}
//    輸出結(jié)果：
//  shared_count: 0

鎖

在多線程編程中，鎖是一種常見的同步機制，它用于保護共享數(shù)據(jù)不受到并發(fā)訪問的影響。Rust標準庫中提供了鎖的實現(xiàn)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());
}
//    輸出結(jié)果：
//  shared_data: 0

RwLock

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

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());
}
//    輸出結(jié)果：
// 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是一種同步機制，它提供了一個點，當多個線程只有在該點處到達才能繼續(xù)執(zhí)行。Barrier有一個計數(shù)器，當計數(shù)器到達值N時，所有在該Barrier處等待的線程可以繼續(xù)執(zhí)行。

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();
}
//    輸出結(jié)果：
// Thread1 step1.
// Thread2 step1.
// ERROR Timeout

最佳實踐：安全地使用Thread

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

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

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

總結(jié)

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