Implement Thread::os_id

library/std/src/thread/current.rs

@@ -246,7 +246,9 @@ pub(crate) fn current_or_unnamed() -> Thread {
             (*current).clone()
         }
     } else if current == DESTROYED {
-        Thread::new(id::get_or_init(), None)
+        let thread = Thread::new(id::get_or_init(), None);
+        thread.set_os_id_to_current();
+        thread
     } else {
         init_current(current)
     }
@@ -292,6 +294,7 @@ fn init_current(current: *mut ()) -> Thread {
         // If the thread ID was initialized already, use it.
         let id = id::get_or_init();
         let thread = Thread::new(id, None);
+        thread.set_os_id_to_current();
 
         // 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 seen_by_the_thread_itself = spawned.join().unwrap();
+    assert_eq!(handle.os_id(), seen_by_the_thread_itself);
+}
+
 #[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,25 @@ 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 }
     }
 
+    /// 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 +218,35 @@ 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 or offers no way to read it,
+    /// or that the thread has not started running yet.
+    ///
+    /// The operating system may hand the same id to a later thread once this one
+    /// exits, so it does not name a thread uniquely over the life of the
+    /// process. It may also no longer refer to this thread at all, since any
+    /// thread but the current one can exit at any point. For anything other than
+    /// the current thread, logging is the only safe use.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(thread_os_id)]
+    /// use std::thread;
+    ///
+    /// let spawned = thread::spawn(|| thread::current().os_id());
+    /// println!("spawned thread ran as {:?}", spawned.join().unwrap());
+    /// ```
+    #[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