Question

并发体系由标准库，而非语言提供支持。这意味着，可能有很多不同的产品可供选择。

• 以 1:1 系统线程来提供并发支持。
• 主线程（main）不会等待其他线程结束。

println! 并发安全。

use std::thread;

fn main() {
  let handler = thread::spawn(|| {
    for i in 1..10 {
      println!("{}", i);
    }
  });

  // 等待线程结束并获取返回值。
  handler.join().unwrap();  
}

use std::thread;

fn main() {

  // 设置线程参数并命名，以便于调试。
  let builder = thread::Builder::new()
                .name("name".into())
                .stack_size(20 * 1024);

  // 返回 Result，应对创建线程失败。
  let handler = builder.spawn(|| {
    for i in 1..10 {
      println!("{}", i);
    }
  }).unwrap();

  handler.join().unwrap();
}

接收闭包函数返回值。

use std::thread;

fn main() {
  let handler = thread::spawn(|| {
    100
  });

  assert_eq!(handler.join().unwrap(), 100);
}

鉴于不同线程生命周期的差异，强制转移环境变量所有权。

至于借用，因编译器无法识别 Join 调用，无法保证 main 生命周期长过新建线程，而导致生命周期问题。

use std::thread;

fn main() {
  let data = vec![1, 2, 3, 4];

  let handler = thread::spawn(|| {
                ^^ may outlive borrowed value `data`
                
    println!("{:?}", &data);
  });

  handler.join().unwrap();
}

use std::thread;

fn main() {
  let data = vec![1, 2, 3, 4];

  let handler = thread::spawn(move || {
    println!("{:?}", &data);
  });

  handler.join().unwrap();
}

作用域线程

非所有权转移方案，可用作用域线程（scoped thread）解决。它确保闭包线程在作用域结束之前完成，而作用域生命周期却可被编译期有效识别。

use std::thread::scope;

fn main() {
  let data = vec![1, 2, 3, 4];

  // 确保所创建线程在此生命周期范围内。
  // 等待（auto join）所有新建线程结束。
  scope(|s| {
    s.spawn(|| {
      println!("{:?}", &data);
    });

    s.spawn(|| {
      println!("{:?}", &data);
    });
  });
}