rust--顶级高手系列--函数部分

rust 都有啥

函数部分：（字母排序）

• A

alloc::alloc //根据给定的布局分配一块内存。

use std::alloc::{alloc, Layout};
use std::ptr;

fn main() {
    unsafe {
        //Layout::from_size_align(10, 2) 用于创建一个表示 10 字节大小和 2 字节对齐要求的内存布局。
        let layout = Layout::from_size_align(10, 2).unwrap();
        let ptr = alloc(layout);
        if ptr.is_null() {
            panic!("Failed to allocate memory");
        }

        // Use the memory (e.g., ptr for some operations)

        // Don't forget to deallocate it eventually (using dealloc)
    }
}

alloc::alloc_zeroed //给定的布局分配一块内存，并且将这块内存初始化为 0。
alloc::dealloc //函数释放之前由 alloc 或 alloc_zeroed 分配的一块内存。

use std::alloc::{alloc, dealloc, Layout};
use std::ptr;

fn main() {
    unsafe {
        let layout = Layout::from_size_align(10, 2).unwrap();
        let ptr = alloc(layout);
        if ptr.is_null() {
            panic!("Failed to allocate memory");
        }

        // Use the memory (e.g., ptr for some operations)

        dealloc(ptr, layout);
    }
}

alloc::handle_alloc_error
alloc::realloc //重新分配一块内存，将数据移动到新位置，并允许扩大或缩小其容量

use std::alloc::{alloc, realloc, dealloc, Layout};
use std::ptr;

fn main() {
    unsafe {
        let layout = Layout::from_size_align(10, 2).unwrap();
        let ptr = alloc(layout);
        if ptr.is_null() {
            panic!("Failed to allocate memory");
        }

        let new_layout = Layout::from_size_align(20, 2).unwrap();
        let new_ptr = realloc(ptr, layout, new_layout.size());
        if new_ptr.is_null() {
            panic!("Failed to reallocate memory");
        }

        // Use the new memory (e.g., new_ptr for some operations)

        dealloc(new_ptr, new_layout);
    }
}

alloc::set_alloc_error_hook //设置一个自定义的内存分配错误处理钩子。

use std::alloc::{set_alloc_error_hook, Layout};

fn custom_alloc_error(layout: Layout) {
    eprintln!("Failed to allocate memory: {:?}", layout);
    std::process::abort();  // 或者其它你想要的行为
}

fn main() {
    set_alloc_error_hook(Box::new(custom_alloc_error));
}

alloc::take_alloc_error_hook //获取当前错误处理钩子并替换为默认钩子。

any::request_ref
any::request_value
any::type_name
any::type_name_of_val

use std::any::type_name;

fn main() {
    let name = type_name::<i32>();
    println!("Type name: {}", name);  // 输出: Type name: i32
}

array::from_fn
array::from_mut
array::from_ref
array::try_from_fn

let arr: [i32; 5] = std::array::from_fn(|i| (i * 2) as i32);
println!("{:?}", arr);  // 输出: [0, 2, 4, 6, 8]

fn main() {
    let mut val = 42;
    let arr = std::array::from_mut(&mut val);
    arr[0] += 1;
    println!("{}", val);  // 输出: 43
}

ascii::escape_default
async_iter::from_iter

---

• C

char::decode_utf16
char::from_digit
//将一个 u32 值转换为 char，如果值在合法的 Unicode 范围内返回 Some(char)
char::from_u32
//与 char::from_u32 类似，但不会进行合法性检查。使用这个方法需要保证输入值是合法的 Unicode 标量值，否则将导致未定义行为（UB）。
char::from_u32_unchecked

fn main() {
    if let Some(ch) = char::from_u32(0x2764) {
        println!("{}", ch);  // 输出: ❤
    } else {
        println!("Invalid Unicode scalar value");
    }

    // 无效的 Unicode
    if let Some(ch) = char::from_u32(0xD800) {
        println!("{}", ch);
    } else {
        println!("Invalid Unicode scalar value");  // D800 是代理对的起始，高代理字节
    }
}

cmp::max
cmp::max_by
cmp::max_by_key
cmp::min
cmp::min_by
cmp::min_by_key

use std::cmp;

fn main() {
    let max_value = cmp::max_by(10, 20, |a, b| a.cmp(b));
    println!("{}", max_value);  // 输出: 20

      let max_value = cmp::max(10, 20);
    println!("{}", max_value);  // 输出: 20
}

convert::identity

---

• E

//返回一个迭代器，通过该迭代器可以获取传递给程序的命令行参数，每个参数都是一个 String。
env::args
//类似于 env::args，但返回的迭代器中的每个参数是 OsString，这对于处理不能保证是有效 UTF-8 的参数特别有用。
env::args_os
env::current_dir //返回当前工作目录的路径。
env::current_exe //返回当前正在执行的可执行文件的路径。
env::home_dir
env::join_paths //将多个路径片段连接成一个用路径分隔符分隔的路径字符串。

use std::env;
use std::ffi::OsString;
use std::io;

fn main() -> io::Result<()> {
    let paths = vec![OsString::from("/usr/bin"), OsString::from("/usr/local/bin")];
    let joined_paths = env::join_paths(paths)?;
    println!("Joined paths: {:?}", joined_paths);
    Ok(())
}

env::remove_var
env::set_current_dir //设置当前工作目录。
env::set_var //设置环境变量的值。

use std::env;

fn main() {
    env::set_var("MY_VAR", "value");
    match env::var("MY_VAR") {
        Ok(value) => println!("MY_VAR is set to: {}", value),
        Err(_) => println!("MY_VAR is not set"),
    }
}

env::split_paths
env::temp_dir
env::var
env::var_os
env::vars

use std::env;

fn main() {
    match env::var("HOME") {
        Ok(value) => println!("HOME is set to: {}", value),
        Err(e) => println!("Couldn't read HOME ({})", e),
    }
}

env::vars_os

---

• F

fmt::format
//fmt::write 函数用于将格式化参数写入到实现了 std::fmt::Write trait 的目标中。最常用的目标是 String 和其他实现了 std::fmt::Write trait 的类型。
fmt::write

use std::fmt;
use std::string::String;

fn main() {
    let mut s = String::new();
    fmt::write(&mut s, format_args!("Hello, {}", "world")).unwrap();
    println!("{}", s);  // 输出: Hello, world
}

fs::canonicalize
fs::copy //复制文件内容到另一个文件。如果目标文件已存在，将会被覆盖。
fs::create_dir //创建一个新目录。如果目录已存在，将返回错误。
//创建一个新目录及其所有父目录。如果目标目录或其中的部分目录已经存在，则不会返回错误。
fs::create_dir_all
//创建一个指向同一文件的硬链接。硬链接允许多个不同路径指向相同的文件内容。
fs::hard_link
// 获取文件或目录的元数据。元数据包括文件大小、权限、修改时间等信息。
fs::metadata
fs::read //用于读取文件的全部内容并以字节向量返回。
// 用于读取目录下的条目（文件和子目录），返回一个迭代器，每个条目都包含详细的信息。
fs::read_dir
fs::read_link //用于读取符号链接（symlink），返回链接指向的地址。
fs::read_to_string //用于将文件的全部内容读取为一个字符串。
fs::remove_dir // 用于删除一个空目录。如果目录不为空，则会返回错误。
fs::remove_dir_all //用于递归删除目录及其所有内容（包括子目录和文件）。
fs::remove_file //用于删除指定的文件。
fs::rename
fs::set_permissions
fs::soft_link
fs::symlink_metadata
fs::try_exists //检查文件或目录是否存在，并返回一个 Result 类型。
fs::write //将给定的数据写入文件，如果文件不存在，它会创建文件；如果文件存在，它会覆盖文件内容。

future::pending //创建一个永远不会就绪的 Future。通常用于测试和一些特殊情况。
//允许你通过提供一个闭包（closure），根据自定义的逻辑来创建一个 Future。这个闭包需要实现 Poll 行为。
future::poll_fn
future::ready //创建一个立即完成并返回给定值的 Future

use futures::future;

#[tokio::main]
async fn main() {
    let pending_future = future::pending::<()>();
    println!("This future never completes."); // This line will not actually be reached.
    pending_future.await;
}

use futures::future;
use std::task::{Context, Poll};
use std::pin::Pin;

fn main() {
    let poll_fn_future = future::poll_fn(|_cx| {
        // Custom polling logic
        Poll::Ready(42) // Replace 42 with the value you want to return
    });

    // In a real async runtime you would use `.await`
    let result = futures::executor::block_on(poll_fn_future);
    println!("Result: {}", result); // Output: Result: 42
}
use futures::future;

#[tokio::main]
async fn main() {
    let ready_future = future::ready(42);
    let result = ready_future.await;
    println!("Result: {}", result); // Output: Result: 42
}

---

• I

io::copy

use std::fs::File;
use std::io::{self, copy};
use std::io::prelude::*; // 导入 Read 和 Write trait

fn main() -> io::Result<()> {
    let mut src = File::open("source.txt")?;
    let mut dst = File::create("destination.txt")?;
    copy(&mut src, &mut dst)?;
    Ok(())
}

io::empty
//io::read_to_string 函数读取数据直到 EOF，并将其读入一个字符串中。
io::read_to_string

use std::fs::File;
use std::io::{self, Read};

fn main() -> io::Result<()> {
    let mut file = File::open("example.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    println!("{}", contents);
    Ok(())
}

io::repeat //创建一个无限重复给定字节的 Read 实现。

#[test]
fn test01() -> Result<(), Box<dyn std::error::Error>> {
    let mut buffer = [0; 10];
    let mut repeater = io::repeat(42);
    repeater.read_exact(&mut buffer)?;
    print!("{:?}", buffer);
    assert_eq!(buffer, [42; 10]);
    Ok(())
}

io::sink

io::stderr
io::stdin
io::stdout

iter::empty //创建一个不包含任何项的空迭代器。
iter::from_fn //创建一个迭代器，每次迭代时会调用给定的闭包，从而生成下一项。

#[test]
fn test01() {
    let mut counter = 0;
    let from_fn_iter = iter::from_fn(|| {
        counter += 1;
        if counter <= 5 {
            Some(counter)
        } else {
            None
        }
    });
    for val in from_fn_iter {
        println!("{}", val); // 输出: 1, 2, 3, 4, 5
    }
}

iter::from_generator

#![feature(generators)]

use std::iter::{self, from_generator};

fn main() {
    let gen = || {
        for i in 0..5 {
            yield i;
        }
    };

    let iter = from_generator(gen);

    for val in iter {
        println!("{}", val); // 输出: 0, 1, 2, 3, 4
    }
}

iter::once //创建一个一次性迭代器，只产生一个指定值。
iter::once_with //类似于 iter::once，但是延迟计算值，只有在迭代时才会生成该值。

use std::iter;

fn main() {
    let once_with_iter = iter::once_with(|| 42);

    for val in once_with_iter {
        println!("{}", val); // 输出: 42
    }
}

iter::repeat

use std::iter;

fn main() {
    let repeat_iter = iter::repeat(42).take(5);

    for val in repeat_iter {
        println!("{}", val); // 输出: 42, 42, 42, 42, 42
    }
}

iter::repeat_with

use std::iter;

fn main() {
    let mut counter = 0;
    let repeat_with_iter = iter::repeat_with(|| {
        counter += 1;
        counter
    }).take(5);

    for val in repeat_with_iter {
        println!("{}", val); // 输出: 1, 2, 3, 4, 5
    }
}

iter::successors //用于创建按需生成一系列值的迭代器

 let init_val: Option<u32> = Some(6);
    let successors_iter = iter::successors(init_val, |&x| {
        if x < 5 {
            Some(x + 1)
        } else {
            None
        }
    });

    for val in successors_iter {
        println!("{}", val); // 输出: 1, 2, 3, 4, 5
    }

iter::zip //创建一个新的迭代器，通过结合两个迭代器的每个元素来生成新的元素对。

use std::iter;

fn main() {
    let iter1 = 0..5;
    let iter2 = 5..10;

    let zip_iter = iter::zip(iter1, iter2);

    for (x, y) in zip_iter {
        //// 输出: (0, 5), (1, 6), (2, 7), (3, 8), (4, 9)
        println!("({}, {})", x, y); 
    }
}

---

• M

mem::align_of //获取类型的对齐要求（字节数）
mem::align_of_val //获取引用值的对齐要求。
mem::align_of_val_raw //获取指针值的对齐要求（裸指针版本）。

use std::mem;

struct Sample {
    a: i32,
    b: u8,
}

fn main() {
    println!("Alignment of i32: {}", mem::align_of::<i32>());
    println!("Alignment of u8: {}", mem::align_of::<u8>());
    println!("Alignment of Sample: {}", mem::align_of::<Sample>());

    let x = 5i32;
    let y: *const i32 = &x;
    println!("Alignment of y: {}", unsafe { mem::align_of_val_raw(y) });
}

mem::copy //从一个内存区域复制到另一个内存区域。

use std::mem;

fn main() {
    let src = [1, 2, 3, 4];
    let mut dst = [0; 4];
    
    unsafe {
        mem::copy(src.as_ptr(), dst.as_mut_ptr(), src.len());
    }
    
    println!("{:?}", dst); // 输出: [1, 2, 3, 4]
}

mem::discriminant

enum MyEnum {
    A,
    B,
    C,
}
#[test]
fn test01() {
    let x = MyEnum::A;
    println!("Discriminant of MyEnum::B: {:?}", mem::discriminant(&x));
}

mem::drop
mem::forget
mem::forget_unsized
mem::min_align_of
mem::min_align_of_val
mem::needs_drop
mem::replace
mem::size_of //获取类型的大小（字节数）。

use std::mem;

fn main() {
    println!("Size of i32: {}", mem::size_of::<i32>());
    println!("Size of u8: {}", mem::size_of::<u8>());
}

mem::size_of_val //获取引用值的大小（字节数）。
mem::size_of_val_raw //获取指针值的大小（裸指针版本）。
mem::swap //替换一个值并返回旧值。

use std::mem;

fn main() {
    let mut x = 5;
    let old_x = mem::replace(&mut x, 10);
    println!("Old x: {}", old_x); // 输出: 5
    println!("New x: {}", x);     // 输出: 10
}

mem::take

use std::mem;

fn main() {
    let mut x = Some(42);
    let y = mem::take(&mut x);
    println!("x: {:?}", x); // 输出: None
    println!("y: {:?}", y); // 输出: Some(42)
}

mem::transmute

use std::mem;

fn main() {
    let x: i32 = 5;
    let y: u32 = unsafe { mem::transmute(x) };
    println!("y: {}", y); // 输出: 5（以无符号形式显示）
}

mem::transmute_copy //复制一个值到另一种类型。

use std::mem;

fn main() {
    let x: i32 = 5;
    let y: u32 = unsafe { mem::transmute_copy(&x) };
    println!("y: {}", y); // 输出: 5（以无符号形式显示）
}

mem::uninitialized

use std::mem::MaybeUninit;

fn main() {
    let x: i32 = unsafe { MaybeUninit::uninit().assume_init() };
    println!("x: {}", x);
}

mem::variant_count //获取枚举的变体数量
mem::zeroed //创建一个已零初始化的值。

---

• O

os::unix::fs::chown //改变文件的所有者
//将当前工作目录改变到指定路径，并将其作为新的根目录。这通常用于沙箱环境。
os::unix::fs::chroot
os::unix::fs::fchown //改变文件的所有者，使用文件描述符。

use std::os::unix::fs::fchown;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::create("some_file.txt")?;

    // Change owner to user id 1000 and group id 1000
    fchown(&file, Some(1000), Some(1000))?;
    Ok(())
}

os::unix::fs::lchown //改变符号链接本身的所有者。
os::unix::fs::symlink //创建符号链接。
os::unix::process::parent_id //获取当前进程的父进程 ID。
os::unix::ucred::impl_linux::peer_cred

//WebAssembly System Interface (WASI) 是一种为 WebAssembly 设计的标准化系统接口，旨在使 WebAssembly 可以在多种环境中（不仅仅是浏览器）运行，尤其是服务器端、嵌入式设备和其他非浏览器环境。它的目标是为 WebAssembly 提供一致且安全的系统调用，使其可以更容易地与操作系统进行交互，从而实现更广泛的应用。
os::wasi::fs::link //创建硬链接。
os::wasi::fs::rename //重命名文件或目录。
os::wasi::fs::symlink //创建符号链接。
os::wasi::fs::symlink_path //创建符号链接，接受路径作为目标。

os::windows::fs::symlink_dir //创建指向目录的符号链接
os::windows::fs::symlink_file //创建指向文件的符号链接

• P

//启用后，每次恐慌都会立即终止程序。这个函数在通常不需要直接调用，而是通过设置环境变量 RUST_BACKTRACE 来配置。
panic::always_abort
panic::catch_unwind // 捕获恐慌，并提供恢复能力

use std::panic;

fn main() {
    let result = panic::catch_unwind(|| {
        println!("About to panic!");
        panic!("This is a panic");
    });

    match result {
        Ok(_) => println!("No panic occurred"),
        Err(_) => println!("Panic was caught"),
    }
}

panic::set_backtrace_style
panic::get_backtrace_style

#[test]
fn test01() {
    panic::set_backtrace_style(BacktraceStyle::Full);

    // 获取当前的回溯风格
    let style = panic::get_backtrace_style();
    match style {
        Some(BacktraceStyle::Short) => println!("Backtrace style is Short"),
        Some(BacktraceStyle::Full) => println!("Backtrace style is Full"),
        None => println!("No backtrace style set"),
        _ => {}
    }

    // 触发恐慌来查看效果
    panic!("This is a test panic");
}

panic::panic_any //引发任意类型的恐慌对象，而不仅仅是字符串或 &'static str。

panic::panic_any(42); // 引发一个用整数作为信息的恐慌
panic::panic_any(String::from("This is a panic with a String"));

use std::panic;

#[derive(Debug)]
struct CustomError {
    code: u32,
    message: String,
}

fn main() {
    let error = CustomError {
        code: 404,
        message: String::from("Page not found"),
    };
    panic::panic_any(error); // 引发自定义类型的恐慌
}

panic::resume_unwind //在捕获恐慌后，继续传播恐慌。

use std::panic;

fn main() {
    let result = panic::catch_unwind(|| {
        println!("About to panic!");
        panic!("This is a panic");
    });

    match result {
        Ok(_) => println!("No panic occurred"),
        Err(err) => {
            println!("Panic was caught, resuming unwind...");
            panic::resume_unwind(err);
        }
    }
}

panic::set_hook //设置自定义的恐慌钩子，允许在恐慌发生时执行特定代码。

use std::panic;

fn main() {
    panic::set_hook(Box::new(|info| {
        println!("Custom panic hook: {:?}", info);
    }));

    println!("About to panic...");
    panic!("This is a panic");
}

panic::take_hook
panic::update_hook //在现有钩子行为上添加额外行为。

#[test]
fn test01() {
    // 获取并保存原有的恐慌钩子
    let original_hook = panic::take_hook();

    // 设置新的恐慌钩子
    panic::set_hook(Box::new(move |info| {
        // 原有的恐慌钩子
        original_hook(info);

        // 新增加的行为
        println!("Additional behavior in panic hook: {:?}", info);
    }));

    println!("About to panic with updated hook...");
    panic!("This is a panic");
}

path::absolute
//这个函数用来判断一个字符是否是路径分隔符。它在 POSIX 系统和 Windows 系统中有不同的实现。
path::is_separator

use std::path::is_separator;

fn main() {
    let char1 = '/';
    let char2 = '\\';
    let char3 = 'a';

    println!("Is '{}' a separator? {}", char1, is_separator(char1)); // true on all systems
    println!("Is '{}' a separator? {}", char2, is_separator(char2)); // true on Windows
    println!("Is '{}' a separator? {}", char3, is_separator(char3)); // false
}

//立即终止当前进程，不执行任何清理工作，通常用于当程序遇到不可恢复的错误或者需要立即停止执行时，例如在断言失败时的处理。
process::abort
//终止当前进程，执行所有必要的清理工作，并返回指定的退出状态。
process::exit
//返回当前进程的唯一标识符（PID）。
process::id
ptr

---

• S

slice::from_mut // 将一个可变引用转换为一个包含单个元素的可变 slice

fn main() {
    let mut x = 42;
    let slice: &mut [i32] = std::slice::from_mut(&mut x);
    slice[0] += 1;
    println!("{:?}", slice); // 输出: [43]
}

slice::from_mut_ptr_range //从一个指针范围创建一个可变 slice

use std::slice;

fn main() {
    let mut arr = [1, 2, 3];
    let start = arr.as_mut_ptr();
    let end = unsafe { start.add(arr.len()) };
    let slice = unsafe { slice::from_mut_ptr_range(start..end) };
    println!("{:?}", slice); // 输出: [1, 2, 3]
}

slice::from_ptr_range //从一个指针范围创建一个不可变 slice。

use std::slice;

fn main() {
    let arr = [1, 2, 3];
    let start = arr.as_ptr();
    let end = unsafe { start.add(arr.len()) };
    let slice = unsafe { slice::from_ptr_range(start..end) };
    println!("{:?}", slice); // 输出: [1, 2, 3]
}

slice::from_raw_parts //从一个指向连续数据的原始指针和长度创建一个不可变 slice。

use std::slice;

fn main() {
    let arr = [1, 2, 3];
    let ptr = arr.as_ptr();
    let len = arr.len();
    let slice = unsafe { slice::from_raw_parts(ptr, len) };
    println!("{:?}", slice); // 输出: [1, 2, 3]
}

slice::from_raw_parts_mut
slice::from_ref //将一个不可变引用转换为一个包含单个元素的不可变 slice。

fn main() {
    let x = 42;
    let slice: &[i32] = std::slice::from_ref(&x);
    println!("{:?}", slice); // 输出: [42]
}

slice::range
//从一个 UTF-8 编码的 Box<[u8]> 创建一个字符串切片，忽略UTF-8有效性检查
str::from_boxed_utf8_unchecked

fn main() {
    let boxed: Box<[u8]> = Box::new([b'h', b'e', b'l', b'l', b'o']);
    let s = unsafe { std::str::from_boxed_utf8_unchecked(boxed) };
    println!("{:?}", s); // 输出: "hello"
}

str::from_utf8 //尝试将字节切片转换为字符串切片，并检查其是否为有效的 UTF-8 编码。

fn main() {
    let bytes = b"hello";
    if let Ok(s) = std::str::from_utf8(bytes) {
        println!("{:?}", s); // 输出: "hello"
    } else {
        println!("Invalid UTF-8");
    }
}

//尝试将可变字节切片转换为可变字符串切片，并检查其是否为有效的 UTF-8 编码。
str::from_utf8_mut
//从字节切片创建一个字符串切片，不进行 UTF-8 检查（危险操作）。
str::from_utf8_unchecked
str::from_utf8_unchecked_mut
//发出一个编译器屏障，保证编译器不会对特定范围内的内存操作进行重新排序。
sync::atomic::compiler_fence
//发出一个硬件屏障，确保在这之前的全部写操作在这之后的任何读操作之前完成。
sync::atomic::fence
//向处理器发出提示，可以在自旋锁中减少功耗或提高性能。不推荐使用 。
推荐 std::hint::spin_loop
sync::atomic::spin_loop_hint
//是无界通道，理论上可以容纳无限多的消息 生产者线程在发送消息时不会阻塞，即使消费者没有及时接收消息，适用于生产者速度快、消费者速度慢的场景，在高吞吐量的情况下避免生产者阻塞。
sync::mpsc::channel
//是有界通道，容量限制由创建时指定，生产者线程在发送消息时如果通道已满，将会阻塞直到有消息被消费者接收并腾出空间。适用于需要对消息流进行更严格控制的场景，可以防止生产者过快产生消息导致内存占用过高。
sync::mpsc::sync_channel

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    // 创建一个容量为2的有界通道
    let (tx, rx) = mpsc::sync_channel(2);

    // 启动一个生产者线程
    thread::spawn(move || {
        for i in 0..5 {
            tx.send(i).unwrap(); // 如果通道已满，将阻塞
            println!("Sent: {}", i);
        }
    });

    // 在主线程中消费消息
    for received in rx {
        println!("Received: {}", received);
        thread::sleep(Duration::from_secs(1)); // 延迟消费模拟处理时间
    }
}

---

• T
  thread::available_parallelism//获取cpu核数
  thread::current //获取当前线程
  thread::panicking
  thread::park //阻塞当前线程
  thread::park_timeout
  thread::park_timeout_ms
  thread::scope //创建一个新的线程范围，用于保证所有线程在范围结束前完成

  #[test]
  fn test01() {
    let var = vec![1, 2, 3];
    thread::scope(|s| {
        s.spawn(|_| {
            println!("A child thread borrowing `var`: {:?}", var);
        });
    }).unwrap();
  }
  
  #[test]
  fn test02() {
    let var = vec![1, 2, 3];
    std::thread::spawn(move ||{
        println!("A child thread borrowing `var`: {:?}", var);
    });
  }

thread::sleep // 将当前线程置于休眠状态，直到指定的时间过期。
thread::sleep_ms
thread::spawn //创建一个新线程， 执行闭包
thread::yield_now//将当前线程从运行状态移动到就绪状态，允许其他线程获得执行机会