//! 原生线程。
//!
//! ## 线程模型
//!
//! 一个正在执行的 Rust 程序由一组原生操作系统线程组成​​，每个线程都有自己的栈和本地状态。线程可以被命名，并为底层同步提供一些内置支持。
//!
//! 线程之间的通信可以通过 [channels]、Rust 的消息传递类型、以及 [其他形式的线程同步](../../std/sync/index.html) 和共享内存数据结构来完成。
//! 特别是，保证线程安全的类型很容易在使用原子引用计数容器的线程之间共享， [`Arc`].
//!
//! Rust 中的致命逻辑错误导致 *线程 panic*，在此期间，线程将展开栈，运行析构函数并释放所拥有的资源。
//! 尽管不是 'try/catch' 机制，但仍可以使用 [`catch_unwind`](../../std/panic/fn.catch_unwind.html) 捕获 Rust 中的 panics (除非使用 `panic=abort` 进行编译) 并从中恢复，或者使用 [`resume_unwind`](../../std/panic/fn.resume_unwind.html) 恢复。
//!
//! 如果未捕获到 panic，则线程将退出，但是可以选择使用 [`join`] 从其他线程中检测到 panic。
//! 如果主线程 panic 而没有捕获 panic，应用程序将以非零退出码退出。
//!
//! 当 Rust 程序的主线程终止时，整个程序将关闭，即使其他线程仍在运行也不例外。但是，该模块为自动等待子线程的终止 (即 join) 提供了便利的功能。
//!
//! ## 生成一个线程
//!
//! 可以使用 [`thread::spawn`][`spawn`] 函数来生成一个新线程:
//!
//! ```rust
//! use std::thread;
//!
//! thread::spawn(move || {
//!     // 这里一些工作
//! });
//! ```
//!
//! 在这个例子中，衍生的线程是从当前线程分离出来的。这意味着它可以比它的父线程 (产生它的线程) 活得长，除非这个父线程是主线程。
//!
//! 父线程也可以等待子线程的完成。调用 [`spawn`] 会产生一个 [`JoinHandle`]，它提供了一个用于等待的 `join` 方法:
//!
//! ```rust
//! use std::thread;
//!
//! let child = thread::spawn(move || {
//!     // 这里一些工作
//! });
//! // 这里一些工作
//! let res = child.join();
//! ```
//!
//! [`join`] 方法返回一个 [`thread::Result`]，其中包含子线程产生的最终值 [`Ok`]，或者如果子进程 panic，则返回给调用 [`panic!`] 的值的 [`Err`]。
//!
//! ## 配置线程
//!
//! 一个新线程可以在通过 [`Builder`] 类型生成之前进行配置，它目前允许您设置子线程的名称和堆栈大小:
//!
//! ```rust
//! # #![allow(unused_must_use)]
//! use std::thread;
//!
//! thread::Builder::new().name("child1".to_string()).spawn(move || {
//!     println!("Hello, world!");
//! });
//! ```
//!
//! ## `Thread` 的类型
//!
//! 线程是通过 [`Thread`] 类型来表示的，您可以通过以下两种方式之一获得该类型:
//!
//! * 通过生成一个新线程，例如使用 [`thread::spawn`][`spawn`] 函数，并在 [`JoinHandle`] 上调用 [`thread`][`JoinHandle::thread`]。
//! * 通过使用 [`thread::current`] 函数来请求当前线程。
//!
//! [`thread::current`] 函数甚至可用于不是由该模块的 API 生成的线程。
//!
//! ## 线程本地存储
//!
//! 该模块还为 Rust 程序提供了线程本地存储的实现。线程本地存储是一种将数据存储到全局变量的方法，程序中的每个线程都有自己的副本。
//! 线程不共享此数据，因此不需要同步访问。
//!
//! 线程本地键拥有它所包含的值，并在线程退出时销毁该值。它是使用 [`thread_local!`] 宏创建的，可以包含 `'static` 的任何值 (没有借用指针)。
//! 它提供了一个访问器函数 [`with`]，该访问器函数产生对指定闭包的值的共享引用。线程本地键只允许共享访问值，因为如果允许可变借用，就无法保证惟一性。
//! 大多数值都希望通过 [`Cell`] 或 [`RefCell`] 类型使用某种形式的 **内部可变性**。
//!
//! ## 命名线程
//!
//! 出于识别目的，线程可以有关联的名称。默认情况下，生成的线程是未命名的。要为线程指定名称，请使用 [`Builder`] 构建该线程，然后将所需的线程名称传递给 [`Builder::name`]。
//! 要从线程内检索线程名，请使用 [`Thread::name`]。
//! 下面是使用线程名的几个例子:
//!
//! * 如果在命名线程中出现 panic，则线程名将显示在 panic 消息中。
//! * 线程名在适用的情况下提供给操作系统 (例如，在类 Unix 平台中为 `pthread_setname_np`)。
//!
//! ## 栈大小
//!
//! 衍生线程的默认栈大小为 2 MiB，尽管这个特定的堆栈大小会在将来发生改变。有两种方法可以手动指定衍生线程的栈大小:
//!
//! * 使用 [`Builder`] 构建线程，并将所需的栈大小传递给 [`Builder::stack_size`]。
//! * 将 `RUST_MIN_STACK` 环境变量设置为代表所需栈大小 (以字节为单位) 的整数。请注意，设置 [`Builder::stack_size`] 将覆盖此设置。
//!
//! 注意，主线程的栈大小不是由 Rust 决定的。
//!
//! [channels]: crate::sync::mpsc
//! [`join`]: JoinHandle::join
//! [`Result`]: crate::result::Result
//! [`Ok`]: crate::result::Result::Ok
//! [`Err`]: crate::result::Result::Err
//! [`thread::current`]: current
//! [`thread::Result`]: Result
//! [`unpark`]: Thread::unpark
//! [`thread::park_timeout`]: park_timeout
//! [`Cell`]: crate::cell::Cell
//! [`RefCell`]: crate::cell::RefCell
//! [`with`]: LocalKey::with
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!
//!

#![stable(feature = "rust1", since = "1.0.0")]
#![deny(unsafe_op_in_unsafe_fn)]

#[cfg(all(test, not(target_os = "emscripten")))]
mod tests;

use crate::any::Any;
use crate::cell::UnsafeCell;
use crate::ffi::{CStr, CString};
use crate::fmt;
use crate::io;
use crate::mem;
use crate::num::NonZeroU64;
use crate::num::NonZeroUsize;
use crate::panic;
use crate::panicking;
use crate::str;
use crate::sync::Arc;
use crate::sys::thread as imp;
use crate::sys_common::mutex;
use crate::sys_common::thread;
use crate::sys_common::thread_info;
use crate::sys_common::thread_parker::Parker;
use crate::sys_common::{AsInner, IntoInner};
use crate::time::Duration;

////////////////////////////////////////////////////////////////////////////////
// 线程本地存储
////////////////////////////////////////////////////////////////////////////////

#[macro_use]
mod local;

#[stable(feature = "rust1", since = "1.0.0")]
pub use self::local::{AccessError, LocalKey};

// thread_local 使用的类型! 访问 TLS 密钥的宏。注意，有两种类型，"OS" 类型和 "fast" 类型。
// OS 线程本地密钥类型是通过平台特定的 API 调用访问的，速度很慢，而快速密钥类型是通过 LLVM 生成的代码访问的，其中 TLS 密钥是由 elf 链接器设置的。
// 请注意，OS TLS 类型始终可用: 在 macOS 上，标准库的编译是对较早的平台版本 (不提供快速 TLS 的支持) 的支持; 最终用户代码在可用的情况下使用快速 TLS 进行编译，但两者都是必需的。
//
//
//
//
//

#[unstable(feature = "libstd_thread_internals", issue = "none")]
#[cfg(target_thread_local)]
#[doc(hidden)]
pub use self::local::fast::Key as __FastLocalKeyInner;
#[unstable(feature = "libstd_thread_internals", issue = "none")]
#[doc(hidden)]
pub use self::local::os::Key as __OsLocalKeyInner;
#[unstable(feature = "libstd_thread_internals", issue = "none")]
#[cfg(all(target_arch = "wasm32", not(target_feature = "atomics")))]
#[doc(hidden)]
pub use self::local::statik::Key as __StaticLocalKeyInner;

// 这仅用于使用 `const {..
// }` 初始化表达式不稳定。
// 如果或者当该语法使用线程局部变量稳定时，这将被简单地删除。
#[doc(hidden)]
#[unstable(feature = "thread_local_const_init", issue = "84223")]
pub const fn require_unstable_const_init_thread_local() {}

////////////////////////////////////////////////////////////////////////////////
// Builder
////////////////////////////////////////////////////////////////////////////////

/// 线程工厂，可用于配置新线程的属性。
///
/// 可以在其上链接方法以对其进行配置。
///
/// 有两种配置可供选择:
///
/// - [`name`]: 指定一个 [线程的关联名][naming-threads]
/// - [`stack_size`]: 指定 [线程所需的栈大小][stack-size]
///
/// [`spawn`] 方法将获取构建器的所有权，并使用给定的配置为线程句柄创建 [`io::Result`]。
///
/// [`thread::spawn`] 自由函数使用默认配置的 `Builder`，并返回其值 [`unwrap`]。
///
/// 当您想从启动线程失败中恢复时，您可能想使用 [`spawn`] 而不是 [`thread::spawn`]，实际上，实际上自由函数会在 `Builder` 方法返回 [`io::Result`] 时 panic。
///
///
/// # Examples
///
/// ```
/// use std::thread;
///
/// let builder = thread::Builder::new();
///
/// let handler = builder.spawn(|| {
///     // 线程代码
/// }).unwrap();
///
/// handler.join().unwrap();
/// ```
///
/// [`stack_size`]: Builder::stack_size
/// [`name`]: Builder::name
/// [`spawn`]: Builder::spawn
/// [`thread::spawn`]: spawn
/// [`io::Result`]: crate::io::Result
/// [`unwrap`]: crate::result::Result::unwrap
/// [naming-threads]: ./index.html#naming-threads
/// [stack-size]: ./index.html#stack-size
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
#[derive(Debug)]
pub struct Builder {
    // 未来线程的名称，以在 panic 消息中进行标识
    name: Option<String>,
    // 衍生线程的栈大小 (以字节为单位)
    stack_size: Option<usize>,
}

impl Builder {
    /// 生成用于生成线程的基本配置，从中可以链接配置方法。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new()
    ///                               .name("foo".into())
    ///                               .stack_size(32 * 1024);
    ///
    /// let handler = builder.spawn(|| {
    ///     // 线程代码
    /// }).unwrap();
    ///
    /// handler.join().unwrap();
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn new() -> Builder {
        Builder { name: None, stack_size: None }
    }

    /// 命名未来线程。当前，该名称仅用于 panic 消息中的标识。
    ///
    /// 该名称不能包含空字节 (`\0`)。
    ///
    /// 有关命名线程的更多信息，请参见 [模块级文档][naming-threads]。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new()
    ///     .name("foo".into());
    ///
    /// let handler = builder.spawn(|| {
    ///     assert_eq!(thread::current().name(), Some("foo"))
    /// }).unwrap();
    ///
    /// handler.join().unwrap();
    /// ```
    ///
    /// [naming-threads]: ./index.html#naming-threads
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn name(mut self, name: String) -> Builder {
        self.name = Some(name);
        self
    }

    /// 设置新线程的栈大小 (以字节为单位)。
    ///
    /// 如果平台指定最小栈大小，则实际栈大小可能大于这个值。
    ///
    /// 有关线程的栈大小的更多信息，请参见 [模块级文档][stack-size]。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new().stack_size(32 * 1024);
    /// ```
    ///
    /// [stack-size]: ./index.html#stack-size
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn stack_size(mut self, size: usize) -> Builder {
        self.stack_size = Some(size);
        self
    }

    /// 通过获取 `Builder` 的所有权产生一个新线程，并向其 [`JoinHandle`] 返回一个 [`io::Result`]。
    ///
    /// 衍生的线程可能比调用者活得长 (除非调用者线程是主线程; 当主线程结束时，整个进程将终止)。
    /// join 句柄可用于阻塞子线程的终止，包括恢复其 panic。
    ///
    /// 有关更完整的文档，请参见 [`thread::spawn`][`spawn`]。
    ///
    /// # Errors
    ///
    /// 与 [`spawn`] 自由函数不同，此方法产生 [`io::Result`] 来捕获在操作系统级别创建线程的任何失败。
    ///
    /// [`io::Result`]: crate::io::Result
    ///
    /// # Panics
    ///
    /// 如果设置了线程名称并且它包含空字节，则会出现 panic。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new();
    ///
    /// let handler = builder.spawn(|| {
    ///     // 线程代码
    /// }).unwrap();
    ///
    /// handler.join().unwrap();
    /// ```
    ///
    ///
    ///
    ///
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn spawn<F, T>(self, f: F) -> io::Result<JoinHandle<T>>
    where
        F: FnOnce() -> T,
        F: Send + 'static,
        T: Send + 'static,
    {
        unsafe { self.spawn_unchecked(f) }
    }

    /// 通过获取 `Builder` 的所有权来产生不受任何生命周期限制的新线程，并将 [`io::Result`] 返回其 [`JoinHandle`]。
    ///
    /// 衍生的线程可能比调用者活得长 (除非调用者线程是主线程; 当主线程结束时，整个进程将终止)。
    /// join 句柄可用于阻塞子线程的终止，包括恢复其 panic。
    ///
    /// 此方法与 [`thread::Builder::spawn`][`Builder::spawn`] 相同，不同之处在于宽松的生命周期界限使其不安全。
    /// 有关更完整的文档，请参见 [`thread::spawn`][`spawn`]。
    ///
    /// # Errors
    ///
    /// 与 [`spawn`] 自由函数不同，此方法产生 [`io::Result`] 来捕获在操作系统级别创建线程的任何失败。
    ///
    /// # Panics
    ///
    /// 如果设置了线程名称并且它包含空字节，则会出现 panic。
    ///
    /// # Safety
    ///
    /// 调用者必须确保所提供的线程闭包或其返回类型中的引用不能超过新建线程的生命周期。可以通过两种方式保证这一点:
    ///
    /// - 确保在丢弃任何引用数据之前已调用 [`join`][`JoinHandle::join`]
    /// - 仅使用具有 `'static` 生命周期界限的类型，即没有 `'static` 引用或仅具有 `'static` 引用的类型 ([`thread::Builder::spawn`][`Builder::spawn`] 和 [`thread::spawn`][`spawn`] 都静态地强制执行此属性)
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(thread_spawn_unchecked)]
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new();
    ///
    /// let x = 1;
    /// let thread_x = &x;
    ///
    /// let handler = unsafe {
    ///     builder.spawn_unchecked(move || {
    ///         println!("x = {}", *thread_x);
    ///     }).unwrap()
    /// };
    ///
    /// // 调用者必须确保已调用 `join()`，否则，如果在执行线程闭包之前 `x` 被丢弃，则可以访问释放的内存!
    /////
    /////
    /// handler.join().unwrap();
    /// ```
    ///
    /// [`io::Result`]: crate::io::Result
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    #[unstable(feature = "thread_spawn_unchecked", issue = "55132")]
    pub unsafe fn spawn_unchecked<'a, F, T>(self, f: F) -> io::Result<JoinHandle<T>>
    where
        F: FnOnce() -> T,
        F: Send + 'a,
        T: Send + 'a,
    {
        let Builder { name, stack_size } = self;

        let stack_size = stack_size.unwrap_or_else(thread::min_stack);

        let my_thread = Thread::new(name);
        let their_thread = my_thread.clone();

        let my_packet: Arc<UnsafeCell<Option<Result<T>>>> = Arc::new(UnsafeCell::new(None));
        let their_packet = my_packet.clone();

        let output_capture = crate::io::set_output_capture(None);
        crate::io::set_output_capture(output_capture.clone());

        let main = move || {
            if let Some(name) = their_thread.cname() {
                imp::Thread::set_name(name);
            }

            crate::io::set_output_capture(output_capture);

            // SAFETY: 传递的堆栈守卫是当前线程的守卫。
            // 这意味着当前线程的栈和新线程的栈已被正确设置并相互保护。
            //
            thread_info::set(unsafe { imp::guard::current() }, their_thread);
            let try_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
                crate::sys_common::backtrace::__rust_begin_short_backtrace(f)
            }));
            // SAFETY: `their_packet` 正好在其上方构建并由闭包 (它是 Arc<...>) 移动，并且 `my_packet` 将与该闭包存储在同一 `JoinInner` 中，这意味着该可变的是安全的 (不对其进行修改并影响一个远的值)。
            //
            //
            //
            unsafe { *their_packet.get() = Some(try_result) };
        };

        Ok(JoinHandle(JoinInner {
            // SAFETY:
            //
            // `imp::Thread::new` 使用 `'static` 生命周期的闭包，因为它是通过 FFI 传递的，或者与不具有强制生命周期概念或方法的强制线程原语一起使用。
            //
            // 如本函数文档的 `Safety` 部分所述，此函数的调用者需要确保传入的生命周期对于线程的生命周期足够长。
            //
            //
            // 同样，`sys` 实现必须保证在线程终止后，对闭包的引用不存在，这由 `Thread::join` 返回表示。
            //
            //
            //
            //
            //
            native: unsafe {
                Some(imp::Thread::new(
                    stack_size,
                    mem::transmute::<Box<dyn FnOnce() + 'a>, Box<dyn FnOnce() + 'static>>(
                        Box::new(main),
                    ),
                )?)
            },
            thread: my_thread,
            packet: Packet(my_packet),
        }))
    }
}

////////////////////////////////////////////////////////////////////////////////
// 自由函数
////////////////////////////////////////////////////////////////////////////////

/// 产生一个新线程，为其返回 [`JoinHandle`]。
///
/// 连接子句柄在被丢弃后将隐式分离子线程。在这种情况下，子线程可能会超过父线程 (除非父线程是主线程; 当主线程结束时，整个进程被终止)。
/// 此外，联接句柄提供了 [`join`] 方法，可用于联接子线程。
/// 如果子线程 panics，则 [`join`] 将返回包含给 [`panic!`] 的参数的 [`Err`]。
///
/// 这将使用 [`Builder`] 的默认参数创建一个线程，如果要指定栈大小或线程名称，请改用此 API。
///
/// 如您在 `spawn` 的签名中所见，给 `spawn` 的闭包及其返回值都有两个约束，让我们对其进行解释:
///
/// - `'static` 约束意味着闭包及其返回值必须具有整个程序执行的生命周期。这样做的原因是，线程可以 `detach` 并使它们在其中创建的生命周期更长。
///   确实，如果线程及其扩展值可以超过调用者的生命周期，我们需要确保它们之后才有效，并且由于我们 *无法* 知道何时返回，因此需要使它们有效尽可能直到程序结束，因此是 `'static` 生命周期。
///
/// - [`Send`] 约束是因为闭包将需要从产生它的线程中传递 *by value* 到新线程。它的返回值需要从新线程传递到 `join` 线程。
///   提醒一下，[`Send`] 标记 trait 表示从线程传递到线程是安全的。[`Sync`] 表示在每个线程之间传递引用是安全的。
///
/// # Panics
///
/// 如果操作系统无法创建线程，则为 Panics; 否则为 0。使用 [`Builder::spawn`] 从此类错误中恢复。
///
/// # Examples
///
/// 创建一个线程。
///
/// ```
/// use std::thread;
///
/// let handler = thread::spawn(|| {
///     // 线程代码
/// });
///
/// handler.join().unwrap();
/// ```
///
/// 如模块文档中所述，线程通常是使用 [`channels`] 进行通信的，这是它通常的外观。
///
/// 此示例还显示了如何使用 `move`，以便将值的所有权授予线程。
///
/// ```
/// use std::thread;
/// use std::sync::mpsc::channel;
///
/// let (tx, rx) = channel();
///
/// let sender = thread::spawn(move || {
///     tx.send("Hello, thread".to_owned())
///         .expect("Unable to send on channel");
/// });
///
/// let receiver = thread::spawn(move || {
///     let value = rx.recv().expect("Unable to receive from channel");
///     println!("{}", value);
/// });
///
/// sender.join().expect("The sender thread has panicked");
/// receiver.join().expect("The receiver thread has panicked");
/// ```
///
/// 线程也可以通过其 [`JoinHandle`] 返回一个值，您可以使用它进行异步计算 (不过 futures 可能更合适)。
///
/// ```
/// use std::thread;
///
/// let computation = thread::spawn(|| {
///     // 一些昂贵的计算。
///     42
/// });
///
/// let result = computation.join().unwrap();
/// println!("{}", result);
/// ```
///
/// [`channels`]: crate::sync::mpsc
/// [`join`]: JoinHandle::join
/// [`Err`]: crate::result::Result::Err
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

/// 获取调用它的线程的句柄。
///
/// # Examples
///
/// 使用 `thread::current()` 获取当前线程的句柄:
///
/// ```
/// use std::thread;
///
/// let handler = thread::Builder::new()
///     .name("named thread".into())
///     .spawn(|| {
///         let handle = thread::current();
///         assert_eq!(handle.name(), Some("named thread"));
///     })
///     .unwrap();
///
/// handler.join().unwrap();
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn current() -> Thread {
    thread_info::current_thread().expect(
        "use of std::thread::current() is not possible \
         after the thread's local data has been destroyed",
    )
}

/// 合作地将一个时间片交给操作系统调度程序。
///
/// 这会调用底层操作系统调度程序的 yield 原语，表明调用线程愿意放弃其剩余的时间片，以便操作系统可以在 CPU 上调度其他线程。
///
/// 在循环中让步的一个缺点是，如果操作系统没有任何其他就绪线程在当前 CPU 上运行，该线程将有效地进行忙等待，这会浪费 CPU 时间和精力。
///
/// 因此，在等待感兴趣的事件时，程序员的首选应该是使用同步设备，例如 [`channel`]、[`Condvar`]、[`Mutex`] 或 [`join`]，因为这些原语是以阻塞方式实现，放弃 CPU 直到感兴趣的事件发生，避免重复让步。
///
///
/// `yield_now` 因此应该很少使用，主要是在需要重复轮询的情况下，因为没有其他合适的方法来了解何时发生了感兴趣的事件。
///
/// # Examples
///
/// ```
/// use std::thread;
///
/// thread::yield_now();
/// ```
///
/// [`channel`]: crate::sync::mpsc
/// [`join`]: JoinHandle::join
/// [`Condvar`]: crate::sync::Condvar
/// [`Mutex`]: crate::sync::Mutex
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub fn yield_now() {
    imp::Thread::yield_now()
}

/// 确定当前线程是否由于 panic 而处于展开状态。
///
/// 此功能的一个常见用途是在编写不安全代码时毒害共享资源，方法是在调用 `drop` 时检查 `panic`。
///
/// 编写安全代码时通常不需要这样做，因为当线程在持有锁时 panic，[`Mutex`][Mutex] 已经中毒了。
///
/// 这也可以在多线程应用程序中使用，以便向其他线程发送消息，警告某个线程已发生 panic (例如，出于监视目的)。
///
///
/// # Examples
///
/// ```should_panic
/// use std::thread;
///
/// struct SomeStruct;
///
/// impl Drop for SomeStruct {
///     fn drop(&mut self) {
///         if thread::panicking() {
///             println!("dropped while unwinding");
///         } else {
///             println!("dropped while not unwinding");
///         }
///     }
/// }
///
/// {
///     print!("a: ");
///     let a = SomeStruct;
/// }
///
/// {
///     print!("b: ");
///     let b = SomeStruct;
///     panic!()
/// }
/// ```
///
/// [Mutex]: crate::sync::Mutex
///
///
///
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn panicking() -> bool {
    panicking::panicking()
}

/// 使当前线程休眠至少指定的时间。
///
/// 由于调度细节或平台相关的功能，线程的睡眠时间可能比指定的持续时间更长。
/// 它永远不会少睡。
///
/// 该函数正在阻塞，因此不应在 `async` 函数中使用。
///
/// # 平台特定的行为
///
/// 在 Unix 平台上，底层的系统调用可能会由于虚假唤醒或信号处理程序而中断。
/// 为了确保至少在指定的持续时间内发生睡眠，此函数可以多次调用该系统。
///
///
/// # Examples
///
/// ```no_run
/// use std::thread;
///
/// // 让我们睡 2 秒钟:
/// thread::sleep_ms(2000);
/// ```
///
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(since = "1.6.0", reason = "replaced by `std::thread::sleep`")]
pub fn sleep_ms(ms: u32) {
    sleep(Duration::from_millis(ms as u64))
}

/// 使当前线程休眠至少指定的时间。
///
/// 由于调度细节或平台相关的功能，线程的睡眠时间可能比指定的持续时间更长。它永远不会少睡。
///
/// 该函数正在阻塞，因此不应在 `async` 函数中使用。
///
/// # 平台特定的行为
///
/// 在 Unix 平台上，底层的系统调用可能会由于虚假唤醒或信号处理程序而中断。
/// 为了确保至少在指定的持续时间内发生睡眠，此函数可以多次调用该系统。
/// 不支持纳秒级睡眠精度的平台会将 `dur` 舍入为最接近的睡眠时间粒度。
///
/// 当前，在 Unix 平台上指定零时长会立即返回，而不会调用基础 [`nanosleep`] 系统调用，而在 Windows 平台上，始终会调用基础 [`Sleep`] 系统调用。
///
/// 如果要产生当前时间切片，则可能需要使用 [`yield_now`]。
///
/// [`nanosleep`]: https://linux.die.net/man/2/nanosleep
/// [`Sleep`]: https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleep
///
/// # Examples
///
/// ```no_run
/// use std::{thread, time};
///
/// let ten_millis = time::Duration::from_millis(10);
/// let now = time::Instant::now();
///
/// thread::sleep(ten_millis);
///
/// assert!(now.elapsed() >= ten_millis);
/// ```
///
///
///
///
///
///
#[stable(feature = "thread_sleep", since = "1.4.0")]
pub fn sleep(dur: Duration) {
    imp::Thread::sleep(dur)
}

/// 阻塞，除非或直到当前线程的 token 可用为止。
///
/// 对 `park` 的调用不能保证线程将永远保持驻留状态，因此调用者应为此做好准备。
///
/// # park 和 unpark
///
/// 每个线程都通过 [`thread::park`][`park`] 函数和 [`thread::Thread::unpark`][`unpark`] 方法提供了一些基本的阻塞支持。
/// [`park`] 阻塞当前线程，然后可以通过在阻塞线程的句柄上调用 [`unpark`] 方法从另一个线程恢复该线程。
///
/// 从概念上讲，每个 [`Thread`] 句柄都有一个关联的 token，该 token 最初不存在:
///
/// * [`thread::park`][`park`] 函数会阻塞当前线程，除非或直到 token 可用于其线程句柄为止，否则该原子将自动消耗 token。
/// 它也可能虚假地返回，而不消耗 token。
/// [`thread::park_timeout`] 这样做是一样的，但是允许指定最长的时间来阻止线程。
///
/// * [`Thread`] 上的 [`unpark`] 方法原子地使 token (如果尚未提供) 可用。
/// 由于最初不存在 token，因此 [`unpark`] 后跟 [`park`] 将导致第二个调用立即返回。
///
/// 换句话说，每个 [`Thread`] 的行为都类似于自旋锁，可以使用 `park` 和 `unpark` 进行锁定和解锁。
///
/// 请注意，被取消阻止并不意味着与取消该线程的某个人进行任何同步，这也可能是虚假的。
/// 例如，将 [`park`] 和 [`unpark`] 都立即返回而无需执行任何操作将是有效但效率低下的实现。
///
/// 通常通过获取当前线程的句柄，将该句柄放置在共享数据结构体中，以便其他线程可以找到它，然后 `park` 在循环中来使用该 API。
///
/// 当满足某些所需条件时，另一个线程将在句柄上调用 [`unpark`]。
///
/// 这种设计的动机是双重的:
///
/// * 在构建新的同步原语时，它无需分配互斥锁和 condvar。线程已经提供了基本的 blocking/signaling。
///
/// * 它可以在许多平台上非常有效地实现。
///
/// # Examples
///
/// ```
/// 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 || {
///     // 我们要等到标志被设置。
///     // 我们可以旋转，但是使用 park/unpark 效率更高。
///     while !flag2.load(Ordering::Acquire) {
///         println!("Parking thread");
///         thread::park();
///         // 我们可以伪装地到达这里，即在下面的 10ms 结束之前!
///         // 但这没问题，我们一直处于循环状态，直到仍然设置了标志。
///         println!("Thread unparked");
///     }
///     println!("Flag received");
/// });
///
/// // 花费一些时间来生成线程。
/// thread::sleep(Duration::from_millis(10));
///
/// // 设置标志，并让线程唤醒。
/// // 这里没有竞态条件，如果 `unpark` 首先出现，则 `park` 将立即返回。
/////
/// // 因此，没有死锁的风险。
/// flag.store(true, Ordering::Release);
/// println!("Unpark the thread");
/// parked_thread.thread().unpark();
///
/// parked_thread.join().unwrap();
/// ```
///
/// [`unpark`]: Thread::unpark
/// [`thread::park_timeout`]: park_timeout
///
///
///
///
///
///
///
///
///
///
///
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub fn park() {
    // SAFETY: 在该线程所拥有的 parker 上调用 park_timeout。
    unsafe {
        current().inner.parker.park();
    }
}

/// 使用 [`park_timeout`]。
///
/// 除非直到当前线程的 token 可用或达到指定的持续时间 (否则可能会虚假唤醒)，否则将阻塞。
///
/// 该函数的语义与 [`park`] 等效，除了线程被阻塞的时间不超过 `dur`。
/// 由于诸如抢占或平台差异之类的异常可能不会导致等待的最大时间恰好为 `ms` 长，因此该方法不应用于精确的计时。
///
///
/// 有关更多详细信息，请参见 [park 文档][`park`]。
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(since = "1.6.0", reason = "replaced by `std::thread::park_timeout`")]
pub fn park_timeout_ms(ms: u32) {
    park_timeout(Duration::from_millis(ms as u64))
}

/// 除非直到当前线程的 token 可用或达到指定的持续时间 (否则可能会虚假唤醒)，否则将阻塞。
///
/// 该函数的语义与 [`park`][park] 等效，除了线程被阻塞的时间不超过 `dur`。
/// 由于诸如抢占或平台差异之类的异常可能不会导致等待的最大时间恰好为 `dur` 长，因此该方法不应用于精确的计时。
///
///
/// 有关更多详细信息，请参见 [park 文档][park]。
///
/// # 平台特定的行为
///
/// 不支持纳秒级睡眠精度的平台会将 `dur` 舍入为最接近的睡眠时间粒度。
///
/// # Examples
///
/// 等待超时完全到期:
///
/// ```rust,no_run
/// use std::thread::park_timeout;
/// use std::time::{Instant, Duration};
///
/// let timeout = Duration::from_secs(2);
/// let beginning_park = Instant::now();
///
/// let mut timeout_remaining = timeout;
/// loop {
///     park_timeout(timeout_remaining);
///     let elapsed = beginning_park.elapsed();
///     if elapsed >= timeout {
///         break;
///     }
///     println!("restarting park_timeout after {:?}", elapsed);
///     timeout_remaining = timeout - elapsed;
/// }
/// ```
///
///
///
///
#[stable(feature = "park_timeout", since = "1.4.0")]
pub fn park_timeout(dur: Duration) {
    // SAFETY: 在该线程所拥有的 parker 上调用 park_timeout。
    unsafe {
        current().inner.parker.park_timeout(dur);
    }
}

////////////////////////////////////////////////////////////////////////////////
// ThreadId
////////////////////////////////////////////////////////////////////////////////

/// 正在运行的线程的唯一标识符。
///
/// `ThreadId` 是不透明的 object，对于创建一个线程的每个线程，它具有唯一的值。
/// 不能保证 ThreadId 与线程的系统指定标识符相对应。
/// 可以从 [`Thread`] 上的 [`id`] 方法中检索 `ThreadId`。
///
/// # Examples
///
/// ```
/// use std::thread;
///
/// let other_thread = thread::spawn(|| {
///     thread::current().id()
/// });
///
/// let other_thread_id = other_thread.join().unwrap();
/// assert!(thread::current().id() != other_thread_id);
/// ```
///
/// [`id`]: Thread::id
///
#[stable(feature = "thread_id", since = "1.19.0")]
#[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]
pub struct ThreadId(NonZeroU64);

impl ThreadId {
    // 生成一个新的唯一线程 ID。
    fn new() -> ThreadId {
        // 尝试重新获得此互斥锁是 UB!
        static GUARD: mutex::StaticMutex = mutex::StaticMutex::new();
        static mut COUNTER: u64 = 1;

        unsafe {
            let guard = GUARD.lock();

            // 如果我们以某种方式用尽了所有位 panic，那么我们就不会掩盖正在重用的 ID 的细微错误。
            //
            if COUNTER == u64::MAX {
                drop(guard); // 如果 panic 处理程序最终调用 `ThreadId::new()`，请避免获取可重入锁。
                panic!("failed to generate unique thread ID: bitspace exhausted");
            }

            let id = COUNTER;
            COUNTER += 1;

            ThreadId(NonZeroU64::new(id).unwrap())
        }
    }

    /// 这将返回此 `ThreadId` 标识的线程的数字标识符。
    ///
    /// 如类型本身的文档中所述，它本质上是一个不透明的 ID，但可以保证每个线程都是唯一的。
    /// 返回的值是完全不透明的 - 仅相等测试是稳定的。
    /// 请注意，不能保证新线程将返回哪些值，并且在 Rust 版本之间可能会改变。
    ///
    ///
    ///
    #[unstable(feature = "thread_id_value", issue = "67939")]
    pub fn as_u64(&self) -> NonZeroU64 {
        self.0
    }
}

////////////////////////////////////////////////////////////////////////////////
// Thread
////////////////////////////////////////////////////////////////////////////////

/// `Thread` 句柄的内部表示
struct Inner {
    name: Option<CString>, // 保证为 UTF-8
    id: ThreadId,
    parker: Parker,
}

#[derive(Clone)]
#[stable(feature = "rust1", since = "1.0.0")]
/// 线程的句柄。
///
/// 线程通过 `Thread` 类型表示，您可以通过以下两种方式之一来获取:
///
/// * 通过生成一个新线程，例如使用 [`thread::spawn`][`spawn`] 函数，并在 [`JoinHandle`] 上调用 [`thread`][`JoinHandle::thread`]。
/// * 通过使用 [`thread::current`] 函数来请求当前线程。
///
/// [`thread::current`] 函数甚至可用于不是由该模块的 API 生成的线程。
///
/// 通常不需要自己创建 `Thread` 结构体，而应使用 `spawn` 之类的函数来创建新线程，有关更多详细信息，请参见 [`Builder`] 和 [`spawn`] 的文档。
///
///
/// [`thread::current`]: current
///
///
///
///
///
pub struct Thread {
    inner: Arc<Inner>,
}

impl Thread {
    // 如果名称包含 nul，则仅在内部用于构造线程 object，而不会产生 Panics。
    //
    pub(crate) fn new(name: Option<String>) -> Thread {
        let cname =
            name.map(|n| CString::new(n).expect("thread name may not contain interior null bytes"));
        Thread {
            inner: Arc::new(Inner { name: cname, id: ThreadId::new(), parker: Parker::new() }),
        }
    }

    /// 通过原子方式使句柄的 token 可用 (如果尚不可用)。
    ///
    /// 每个线程都通过 [`park`][park] 函数和 `unpark()` 方法提供了一些基本的阻塞支持。
    /// 这些可用作自旋锁的 CPU 效率更高的实现。
    ///
    /// 有关更多详细信息，请参见 [park 文档][park]。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    /// use std::time::Duration;
    ///
    /// let parked_thread = thread::Builder::new()
    ///     .spawn(|| {
    ///         println!("Parking thread");
    ///         thread::park();
    ///         println!("Thread unparked");
    ///     })
    ///     .unwrap();
    ///
    /// // 花费一些时间来生成线程。
    /// thread::sleep(Duration::from_millis(10));
    ///
    /// println!("Unpark the thread");
    /// parked_thread.thread().unpark();
    ///
    /// parked_thread.join().unwrap();
    /// ```
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    #[inline]
    pub fn unpark(&self) {
        self.inner.parker.unpark();
    }

    /// 获取线程的唯一标识符。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let other_thread = thread::spawn(|| {
    ///     thread::current().id()
    /// });
    ///
    /// let other_thread_id = other_thread.join().unwrap();
    /// assert!(thread::current().id() != other_thread_id);
    /// ```
    #[stable(feature = "thread_id", since = "1.19.0")]
    pub fn id(&self) -> ThreadId {
        self.inner.id
    }

    /// 获取线程的名称。
    ///
    /// 有关命名线程的更多信息，请参见 [模块级文档][naming-threads]。
    ///
    ///
    /// # Examples
    ///
    /// 默认情况下，线程未指定名称:
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new();
    ///
    /// let handler = builder.spawn(|| {
    ///     assert!(thread::current().name().is_none());
    /// }).unwrap();
    ///
    /// handler.join().unwrap();
    /// ```
    ///
    /// 具有指定名称的线程:
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new()
    ///     .name("foo".into());
    ///
    /// let handler = builder.spawn(|| {
    ///     assert_eq!(thread::current().name(), Some("foo"))
    /// }).unwrap();
    ///
    /// handler.join().unwrap();
    /// ```
    ///
    /// [naming-threads]: ./index.html#naming-threads
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn name(&self) -> Option<&str> {
        self.cname().map(|s| unsafe { str::from_utf8_unchecked(s.to_bytes()) })
    }

    fn cname(&self) -> Option<&CStr> {
        self.inner.name.as_deref()
    }
}

#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Debug for Thread {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Thread")
            .field("id", &self.id())
            .field("name", &self.name())
            .finish_non_exhaustive()
    }
}

////////////////////////////////////////////////////////////////////////////////
// JoinHandle
////////////////////////////////////////////////////////////////////////////////

/// 线程专用的 [`Result`] 类型。
///
/// 指示线程退出的方式。
///
/// `Result::Err` 成员中包含的值是被恐慌的线程的值;
/// 也就是说，调用了 `panic!` 宏的参数。
/// 与正常错误不同，此值不实现 [`Error`](crate::error::Error) trait。
///
/// 因此，处理线程 panic 的明智方法是:
///
/// 1. 用 [`std::panic::resume_unwind`] 传播 panic
/// 2.
/// 或如果线程打算作为子系统边界来隔离系统级故障，在 `Err` 成员上进行匹配并以适当的方式处理 panic
///
///
/// 没有恐慌地完成的线程被认为已成功退出。
///
/// # Examples
///
/// 匹配已连接线程的结果:
///
/// ```no_run
/// use std::{fs, thread, panic};
///
/// fn copy_in_thread() -> thread::Result<()> {
///     thread::spawn(|| {
///         fs::copy("foo.txt", "bar.txt").unwrap();
///     }).join()
/// }
///
/// fn main() {
///     match copy_in_thread() {
///         Ok(_) => println!("copy succeeded"),
///         Err(e) => panic::resume_unwind(e),
///     }
/// }
/// ```
///
/// [`Result`]: crate::result::Result
/// [`std::panic::resume_unwind`]: crate::panic::resume_unwind
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub type Result<T> = crate::result::Result<T, Box<dyn Any + Send + 'static>>;

// 该数据包用于在子线程和父线程之间传递返回值。内存是通过内部的 `Arc` 共享的，这里不需要互斥锁，因为与 `join()` 进行了同步 (父线程在子级退出之前永远不会读取此数据包)。
//
// 然后将此数据包本身存储到 `JoinInner` 中，该 `JoinInner` 依次放置在 `JoinHandle` 和 `JoinGuard` 中。由于使用了 `UnsafeCell`，我们需要手动担心诸如发送和同步之类的冲动。`T` 类型应该已经始终是 Send (否则无法创建线程)，并且此类型固有地是 Sync，因为没有方法采用 &self。
//
// 但是，无论如何，我们都将 Send/Sync 的继承的 impls 添加到此类型，以确保它是 Send/Sync，并且 future 修改仍将其适当地分类。
//
//
//
//
//
//
//
struct Packet<T>(Arc<UnsafeCell<Option<Result<T>>>>);

unsafe impl<T: Send> Send for Packet<T> {}
unsafe impl<T: Sync> Sync for Packet<T> {}

/// JoinHandle 的内部表示
struct JoinInner<T> {
    native: Option<imp::Thread>,
    thread: Thread,
    packet: Packet<T>,
}

impl<T> JoinInner<T> {
    fn join(&mut self) -> Result<T> {
        self.native.take().unwrap().join();
        unsafe { (*self.packet.0.get()).take().unwrap() }
    }
}

/// 拥有加入线程的权限 (在线程终止时阻止)。
///
/// `JoinHandle` 在被丢弃时会 *分离* 相关的线程，这意味着不再有线程句柄，也无法在其上访问 `join`。
///
///
/// 由于平台的限制，无法使用 [`Clone`] 此句柄: 加入线程的能力是唯一拥有的权限。
///
/// 该 `struct` 由 [`thread::spawn`] 函数和 [`thread::Builder::spawn`] 方法创建。
///
/// # Examples
///
/// 从 [`thread::spawn`] 创建:
///
/// ```
/// use std::thread;
///
/// let join_handle: thread::JoinHandle<_> = thread::spawn(|| {
///     // 这里一些工作
/// });
/// ```
///
/// 从 [`thread::Builder::spawn`] 创建:
///
/// ```
/// use std::thread;
///
/// let builder = thread::Builder::new();
///
/// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {
///     // 这里一些工作
/// }).unwrap();
/// ```
///
/// 子节点离开父节点并活的更久
///
/// ```no_run
/// use std::thread;
/// use std::time::Duration;
///
/// let original_thread = thread::spawn(|| {
///     let _detached_thread = thread::spawn(|| {
///         // 在这里我们睡觉以确保第一个线程在此之前返回。
///         thread::sleep(Duration::from_millis(10));
///         // 即使 JoinHandle 被丢弃，也将调用它。
///         println!("♫ Still alive ♫");
///     });
/// });
///
/// original_thread.join().expect("The thread being joined has panicked");
/// println!("Original thread is joined.");
///
/// // 我们确保在主线程返回之前，新线程有时间运行。
/////
///
/// thread::sleep(Duration::from_millis(1000));
/// ```
///
/// [`thread::Builder::spawn`]: Builder::spawn
/// [`thread::spawn`]: spawn
///
///
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct JoinHandle<T>(JoinInner<T>);

#[stable(feature = "joinhandle_impl_send_sync", since = "1.29.0")]
unsafe impl<T> Send for JoinHandle<T> {}
#[stable(feature = "joinhandle_impl_send_sync", since = "1.29.0")]
unsafe impl<T> Sync for JoinHandle<T> {}

impl<T> JoinHandle<T> {
    /// 提取基础线程的句柄。
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new();
    ///
    /// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {
    ///     // 这里一些工作
    /// }).unwrap();
    ///
    /// let thread = join_handle.thread();
    /// println!("thread id: {:?}", thread.id());
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn thread(&self) -> &Thread {
        &self.0.thread
    }

    /// 等待关联的线程完成。
    ///
    /// 就 [atomic memory orderings] 而言，关联线程的完成与此函数返回同步。
    /// 换句话说，在 `join` 返回之后发生的所有操作之前，将对该线程执行的所有操作进行排序。
    ///
    /// 如果子线程 panics，则使用给 [`panic!`] 的参数返回 [`Err`]。
    ///
    /// [`Err`]: crate::result::Result::Err
    /// [atomic memory orderings]: crate::sync::atomic
    ///
    /// # Panics
    ///
    /// 如果某个线程尝试加入自身，则该函数在某些平台上可能为 panic，否则可能会在加入线程时产生死锁。
    ///
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread;
    ///
    /// let builder = thread::Builder::new();
    ///
    /// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {
    ///     // 这里一些工作
    /// }).unwrap();
    /// join_handle.join().expect("Couldn't join on the associated thread");
    /// ```
    ///
    ///
    ///
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn join(mut self) -> Result<T> {
        self.0.join()
    }
}

impl<T> AsInner<imp::Thread> for JoinHandle<T> {
    fn as_inner(&self) -> &imp::Thread {
        self.0.native.as_ref().unwrap()
    }
}

impl<T> IntoInner<imp::Thread> for JoinHandle<T> {
    fn into_inner(self) -> imp::Thread {
        self.0.native.unwrap()
    }
}

#[stable(feature = "std_debug", since = "1.16.0")]
impl<T> fmt::Debug for JoinHandle<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("JoinHandle").finish_non_exhaustive()
    }
}

fn _assert_sync_and_send() {
    fn _assert_both<T: Send + Sync>() {}
    _assert_both::<JoinHandle<()>>();
    _assert_both::<Thread>();
}

/// 返回程序可用的硬件线程数。
///
/// 此值应仅视为提示。
///
/// # 平台特定的行为
///
/// 如果将其解释为实际的硬件线程数，则在具有 64 个以上的硬件线程的 Windows 系统上，它可能会被低估。
/// 如果将其解释为该进程的可用并发性，则在受进程范围的亲和力掩码或作业 object 限制的情况下，它可能在 Windows 系统上计数过多，而在受到进程范围的亲和力掩码的限制或 cgroups 限制的影响下，它在 Linux 系统上可能计数过多。
///
///
/// # Errors
///
/// 在以下情况下，此函数将返回错误，但不仅限于这些情况:
///
/// - 目标平台的硬件线程数是否未知。
/// - 该进程缺乏查看可用硬件线程数的权限。
///
/// # Examples
///
/// ```
/// # #![allow(dead_code)]
/// #![feature(available_concurrency)]
/// use std::thread;
///
/// let count = thread::available_concurrency().map(|n| n.get()).unwrap_or(1);
/// ```
///
///
///
///
///
#[unstable(feature = "available_concurrency", issue = "74479")]
pub fn available_concurrency() -> io::Result<NonZeroUsize> {
    imp::available_concurrency()
}