Implement Thread::os_id

library/std/src/thread/current.rs

@@ -246,7 +246,8 @@ pub(crate) fn current_or_unnamed() -> Thread {
             (*current).clone()
         }
     } else if current == DESTROYED {
-        Thread::new(id::get_or_init(), None)
+        let id = id::get_or_init();
+        Thread::new_current(id, None)
     } else {
         init_current(current)
     }
@@ -291,7 +292,7 @@ fn init_current(current: *mut ()) -> Thread {
         CURRENT.set(BUSY);
         // If the thread ID was initialized already, use it.
         let id = id::get_or_init();
-        let thread = Thread::new(id, None);
+        let thread = Thread::new_current(id, None);
 
         // Make sure that `crate::rt::thread_cleanup` will be run, which will
         // call `drop_current`.

library/std/src/thread/lifecycle.rs

@@ -141,6 +141,10 @@ impl ThreadInit {
             rtabort!("current thread handle already set during thread spawn");
         }
 
+        // The handle was created by the spawning thread, so only now that we are
+        // running can the OS id be filled in.
+        self.handle.set_os_id_to_current();
+
         if let Some(name) = self.handle.cname() {
             imp::set_name(name);
         }

library/std/src/thread/tests.rs

@@ -356,6 +356,19 @@ fn test_thread_os_id_not_equal() {
     assert!(current_id != spawned_id);
 }
 
+#[test]
+fn test_thread_os_id_matches_current() {
+    assert_eq!(thread::current().os_id(), crate::sys::thread::current_os_id());
+}
+
+#[test]
+fn test_thread_os_id_of_spawned_thread() {
+    let spawned = thread::spawn(|| thread::current().os_id());
+    let handle = spawned.thread().clone();
+    let spawned_id = spawned.join().unwrap();
+    assert_eq!(handle.os_id(), spawned_id);
+}
+
 #[test]
 fn test_scoped_threads_drop_result_before_join() {
     let actually_finished = &AtomicBool::new(false);

library/std/src/thread/thread.rs

@@ -4,8 +4,9 @@ use crate::alloc::System;
 use crate::ffi::CStr;
 use crate::fmt;
 use crate::pin::Pin;
-use crate::sync::Arc;
+use crate::sync::{Arc, OnceLock};
 use crate::sys::sync::Parker;
+use crate::sys::thread as imp;
 use crate::time::Duration;
 
 // This module ensures private fields are kept private, which is necessary to enforce the safety requirements.
@@ -49,6 +50,7 @@ use thread_name_string::ThreadNameString;
 struct Inner {
     name: Option<ThreadNameString>,
     id: ThreadId,
+    os_id: OnceLock<u64>,
     parker: Parker,
 }
 
@@ -103,13 +105,34 @@ impl Thread {
             let ptr = Arc::get_mut_unchecked(&mut arc).as_mut_ptr();
             (&raw mut (*ptr).name).write(name);
             (&raw mut (*ptr).id).write(id);
+            (&raw mut (*ptr).os_id).write(OnceLock::new());
             Parker::new_in_place(&raw mut (*ptr).parker);
             Pin::new_unchecked(arc.assume_init())
         };
 
         Thread { inner }
     }
 
+    /// Creates a handle for the calling thread, recording its OS id.
+    ///
+    /// `id` must be the `ThreadId` of the calling thread.
+    pub(crate) fn new_current(id: ThreadId, name: Option<String>) -> Thread {
+        let thread = Thread::new(id, name);
+        thread.set_os_id_to_current();
+        thread
+    }
+
+    /// Records the OS id of the calling thread in this handle.
+    ///
+    /// May only be called from the thread to which this handle belongs. A
+    /// spawned thread does this itself once it starts running, since its handle
+    /// already exists by then.
+    pub(crate) fn set_os_id_to_current(&self) {
+        if let Some(os_id) = imp::current_os_id() {
+            let _ = self.inner.os_id.set(os_id);
+        }
+    }
+
     /// Like the public [`park`], but callable on any handle. This is used to
     /// allow parking in TLS destructors.
     ///
@@ -204,6 +227,38 @@ impl Thread {
         self.inner.id
     }
 
+    /// Gets the id the operating system gave this thread, if it has one that can
+    /// be read.
+    ///
+    /// This is the id that shows up in tools like `ps` and `top`, debuggers and
+    /// crash logs, unlike [`ThreadId`], which has no guaranteed relationship to
+    /// it. `None` means the platform has no such id, the thread has not started
+    /// running yet, or the id could not be read.
+    ///
+    /// Ids are unique among threads running at the same moment, but the
+    /// operating system may reuse the id of a thread that has exited, and a
+    /// `Thread` handle can outlive the thread it refers to. As long as you know
+    /// the thread is running, the id still refers to that thread; for the
+    /// current thread you always know. When you do not, use the id only where a
+    /// repeated id is harmless, such as logging.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(thread_os_id)]
+    /// use std::thread;
+    ///
+    /// let spawned = thread::spawn(|| thread::current().os_id()).join().unwrap();
+    /// if spawned.is_some() {
+    ///     assert_ne!(spawned, thread::current().os_id());
+    /// }
+    /// ```
+    #[unstable(feature = "thread_os_id", issue = "160215")]
+    #[must_use]
+    pub fn os_id(&self) -> Option<u64> {
+        self.inner.os_id.get().copied()
+    }
+
     /// Gets the thread's name.
     ///
     /// For more information about named threads, see