Functional Pointers
也有類似c++的函式指標功能, 這樣就可以把函式當參數在傳了
適合實作callback/delegate
fn add(x: u32, y: u32) -> u32 {
x + y
}
fn square(x: u32) -> u32 {
x * x
}
fn sum_of_squares(num: u32, sq: fn(u32) -> u32, add: fn(u32, u32) -> u32) -> u32 {
let mut result = 0;
for i in 1..=num {
result = add(result, sq(i));
}
result
}
fn main() {
let num = 4;
let sum = sum_of_squares(num, square, add);
println!("Sum of squares from 1 to {} = {}", num, sum);
}
Iterators
Rust提供的設計模式之一, 可以方便存取一些容器(例如陣列)的元素
例如用在for loop就不用寫index了, 每個Iterator一定要實作fn next()
struct Counter {
current: u32,
max: u32,
}
impl Counter {
fn new(max: u32) -> Counter {
Counter { current: 0, max }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.current < self.max
{
let result = self.current;
self.current += 1;
Some(result)
}
else
{
None
}
}
}
fn main() {
let mut counter = Counter::new(3);
assert!(matches!(counter.next(), Some(0)));
assert!(matches!(counter.next(), Some(1)));
assert!(matches!(counter.next(), Some(2)));
assert!(matches!(counter.next(), None));
}
Combinators
讓我們可以用條件從一個容器篩選出想要的結果
效果類似於在c++使用lambda expression來篩選結果
let words = vec![“apple”, “banana”];
let result: Vec<String> = words
.into_iter()
.filter( |&word| worl.starts_with(“a”) || words.starts_with(“b”))
.map( |word| word.to_uppercase())
.collect();
fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let result: i32 = numbers
.iter()
.filter(|&&num| num % 2 != 0)
.map(|&num| num * num)
.sum();
println!("Result without combinators: {}", result);
}
Lifetimes
開始關於記憶體管理的東西了
在Rust裡保證不會有dangling reference, borrow checker會在編譯時做檢查
原則上一個變數的生命週期是基於scope, 全域還是局部分清楚就好了
// 這樣不行, j活得不夠久
let i;
{
let j = 5;
i = &j;
}
println!(“i: {i}”);
Box smart pointer
Rust智慧型指標的其中一種, 比起用&表示的simple pointer(reference)有更多能耐
與c++的std::unique_ptr很像, 所有權是獨立的
// data copy
struct Huge_Data;
let data_1 = Huge_Data;
let data_2 = Box::new(Huge_Data);
// data_3 will copy whole stack
// data_4 will only copy the pointer, which is smaller. Actual data is still in heap.
let data_3 = data1;
let data_4 = data2;
// more complicated sample
struct AudioSample;
struct ImageFile;
trait Media {}
impl Media for AudioSample {}
impl Media for ImageFile {}
fn main() {
let audio_1 = AudioSample;
let audio_2 = Box::new(AudioSample);
let audio_3 = audio_1;
let audio_4 = audio_2;
let image_1 = Box::new(ImageFile);
let media_collection: Vec<Box<dyn Media>> = vec![Box::new(audio_3), audio_4, image_1]; // Fix this line
}
Rc smart pointer
也就是reference counting智慧指標! 常用在GC系統
跟c++的shared_ptr很像
use std::rc:Rc;
let a = Rc::new( /* something */);
// this does not do deep copy like other clone() impl, but only increase ref count
let b = Rc::clone(&a);
變數的生命週期結束時, ref count會-1
Concurrency
令人振奮的Thread章節~建立執行緒的方法類似於c++的std::thread
只要呼叫thread::spawn, 並且用join()等待完成即可
use std::thread;
use std::time::Duration;
// similar as c++ std::thread, this kicks off a thread immediately
let t = thread::spawn(|| {
println!(“Hello 1 from the thread”);
println!(“Hello 2 from the thread”);
println!(“Hello 3 from the thread”);
});
//thread::sleep(Duration::from_millis(1));
t.join();
println!(“Hello 1 from the main”);
println!(“Hello 2 from the main”);
Thread Ownership
變數的所有權和c++ lamdba thread類似, 從thread函式裡面不能存取執行緒外面的變數
因此需要move關鍵字, 但如此一來就不能在main()存取x
fn main() {
let x = “some string”.to_string();
// need the move keyword to access x
thread::spawn(move || {
println!(“{x}”);
});
// x isn’t available now, unless the x is stored on the stack
}
Message Passing
執行緒之間如何聯繫? 其中一個方法就是message passing
多個訊息由一個接收者處理
// multiple producer single consumer
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
for i in 0..10 {
let tx_clone = tx.clone();
thread::spawn(move ||{
//let mut i = “5”.to_string();
println!(“Sending value {i}”);
tx_clone .send(i).unwrap();
});
}
// tx was cloned but not dropped, which will cause the program hanging in the end, so be sure to drop it
drop(tx);
// results will follow FIFO rule, it receives the value whoever sent first
for message in rx {
println!(“Received {message}”);
}
}
Sharing States
執行緒之間分享資料的另一種方法, 也就是經典的mutex
在離開一個scope時它會自動unlock, 但有時候也需要呼叫drop(Mutex)來手動解除
以免程式卡住
// sample 1
use std::thread;
use std::sync::Mutex;
fn main() {
let m = Mutex::new(5);
{
let mut num = m.lock.unwrap();
*num = 10;
// it will be unlocked after this scope
}
}
Scoped Threads
另一種thread的用法, 可以省去move關鍵字
而且被使用的變數所有權不會轉移, 回到main函式還能繼續存取
新版Rust (1.63.0之後)才有的功能
fn main() {
let mut vec = vec![1,2,3].
thread::scope(|some_scope| {
some_scope.spawn(|| {
println!(“Thread inside scope”);
println!(“vec: {:?}”, vec);
});
});
println!(“The scope finished”);
vec.push(5);
// 1235
println!(“vec: {:?}”, vec);
}
Thread Parking
在thread上呼叫park()進入等待狀態
在main函式呼叫unpark()喚醒thread繼續運作
let data = Arc::new(Mutex::new(5));
let data_clone = data.clone();
let thread_1 = thread::spawn(move || {
// wait signal from main()
thread::park();
// can use timeout variation as well
// thread::park_timeout(Duration::from_secs(4));
println!(“Thread 1: Data: {:?}”, *data.lock().unwrap());
});
let thread_2 = thread::spawn(move || {
*data_clone .lock().unwrap() = 10;
});
thread_2.join();
// wake up thread_1
thread_1.thread().unpark();
thread_1.join();
Async Await
在Rust裡做到類似Coroutines的方法 (需要Tokio tasks)
如果在async函式裡呼叫sleep(), 它會相當於yield而不是真的睡眠
還可以用flavor來指定要讓工作偏向哪個執行緒來執行
// async keyword
async fn printing(i: i32) {
// use Tokio sleep function to yield
// sleep(Duration::from_secs(1)).await;
println!(“Task {i}”);
}
// use flavor to change task assignment behavior
#[tokio::main(flavor = “current_thread”)]
async fn main () {
let mut handles = vec![];
for i in 0..3 {
let handle = tokio::spawn(async move {
println!(“Task {i}, first time”);
printing(i).await;
println!(“Task {i}, second time”);
printing(i).await;
println!(“Task {i}, completed”);
});
handles.push(handle);
}
for handle in handles {
handle.await.unwrap();
}
println!(“All tasks are now completed”);
}
============================================================
創作內容
Rust語言筆記(下)
工作 (54)
