rust多线程，和erlang非常类似，都使用spawn创建一个线程。例如一个erlang的例子
-module(thread_example).
-export([start/0]).
% 定义要在新线程中执行的函数
print_message() ->
io:format("Hello from the new thread~n").
% 启动函数
start() ->
% 使用spawn函数创建一个新的线程，并传递print_message函数
spawn(fun print_message/0),
ok.
对比一下rust，可以发现erlang和rust及其相似，rust学习了erlang。
1. rust创建线程
rust使用thread包负责创建线程，spawn定义如下：
pub fn spawn<F, T>(f: F) -> JoinHandle<T> where F: FnOnce() -> T, F: Send + 'static, T: Send + 'static,
一个例子代码：
let mut handles = vec![];
for i in 0..NTHREADS {
handles.push(thread::spawn(move || { println!("this is thread number {}", i);}));
}
println!("waiting for every thread");
for handle in handles {
handle.join();
}
例如说这个例子，创建10个线程，每个线程打印一个数字。
- 注意spawn使用了闭包，打印了一个外部变量，而spawn的定义F:FnOnce()，所以在闭包前使用了move，将i的所有权转给闭包。
- spawn返回JoinHandler，有三个方法
- pub fn is_finished(&self) -> bool，判断该线程是否运行完毕
- pub fn join(self) -> Result<T, Err>，调用该方法的线程会等到handle持有线程运行完毕
- pub fn thread(&self) -> &Thread，返回handler对应的thread
1.1 thread::Tread获取线程的id和名字
use std::thread;
// This is the `main` thread
fn main() {
println!("{:?}", thread::current().id());
println!("{:?}", thread::current().name());
}
返回：
ThreadId(1)
Some("main")
let handler = thread::spawn(move || {println!("hello")});
prantln!("{:?}", handler.thread().id());
prantln!("{:?}", handler.thread().name());
返回：
ThreadId(2)
None
1.2 thread::Builder(如何给thread命名)
let builder = thread::Builder::new()
.name("foo".into());
let handler = builder.spawn(|| {
println!("{：？}", thread::current().name())；
}).unwrap();
handler.join().unwrap();
1.3 线程中如何传递共享参数
let v = Arc::new(Mutex::new(vec![1,2,3]));
let mut handlers = vec![];
for i in 0..3 {
let clone_v = v.clone();
handlers.push(thread::spawn(move || {clone_v.lock().unwrap().push(i)}));
}
for handler in handlers {
let _ = handler.join();
}
println!("{:?}", v.lock().unwrap());
共享参数使用Arc只能指针来传递，Arc是个引用，其指向的值并未被复制。在操作的时候使用Mutex来完成同步。
1.4 thread::park和thread:unpark
use std::thread;
use std::sync::{Arc, atomic::{Ordering, AtomicBool}};
use std::time::Duration;
let flag = Arc::new(AtomicBool::new(false));
let flag2 = Arc::clone(&flag);
let parked_thread = thread::spawn(move || {
// We want to wait until the flag is set. We *could* just spin, but using
// park/unpark is more efficient.
while !flag2.load(Ordering::Acquire) {
println!("Parking thread");
thread::park();
// We *could* get here spuriously, i.e., way before the 10ms below are over!
// But that is no problem, we are in a loop until the flag is set anyway.
println!("Thread unparked");
}
println!("Flag received");
});
// Let some time pass for the thread to be spawned.
thread::sleep(Duration::from_millis(10));
// Set the flag, and let the thread wake up.
// There is no race condition here, if `unpark`
// happens first, `park` will return immediately.
// Hence there is no risk of a deadlock.
flag.store(true, Ordering::Release);
println!("Unpark the thread");
parked_thread.thread().unpark();
parked_thread.join().unwrap();
注意这里调用thread::park()阻塞的是当前线程，而接触阻塞调用的是handler.thread().unpark()。
另外还有thread::park_timeout()方法，对阻塞设置超时。
小结
thread包封装了比较简洁的方法，提供线程相关的操作，thread包提供了join和park方法完成线程之间的协作；构造了JoinHandler、Builder、Thread、ThreadId等结构，有序的组合除了thread操作。学习thread包，应把doc文档好好看一遍，消化第一手知识，而不要只看文章，看别人消化了加工出的知识。
