thread_id/lib.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
// Thread-ID -- Get a unique thread ID
// Copyright 2016 Ruud van Asseldonk
//
// Licensed under either the Apache License, Version 2.0, or the MIT license, at
// your option. A copy of both licenses has been included in the root of the
// repository.
//! Thread-ID: get a unique ID for the current thread.
//!
//! For diagnostics and debugging it can often be useful to get an ID that is
//! different for every thread. This crate provides that functionality.
//!
//! # Example
//!
//! ```
//! use std::thread;
//! use thread_id;
//!
//! let handle = thread::spawn(move || {
//! println!("spawned thread has id {}", thread_id::get());
//! });
//!
//! println!("main thread has id {}", thread_id::get());
//!
//! handle.join().unwrap();
//! ```
#![warn(missing_docs)]
#[cfg(unix)]
extern crate libc;
#[cfg(windows)]
extern crate windows_sys;
/// Returns a number that is unique to the calling thread.
///
/// Calling this function twice from the same thread will return the same
/// number. Calling this function from a different thread will return a
/// different number.
#[inline]
pub fn get() -> usize {
get_internal()
}
#[cfg(all(
unix,
not(any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "watchos"
))
))]
#[inline]
fn get_internal() -> usize {
unsafe { libc::pthread_self() as usize }
}
#[cfg(all(
unix,
any(
target_os = "macos",
target_os = "ios",
target_os = "tvos",
target_os = "watchos"
)
))]
#[inline]
fn get_internal() -> usize {
let mut tid: u64 = 0;
unsafe {
libc::pthread_threadid_np(libc::pthread_self(), &mut tid as *mut u64);
};
tid as usize
}
#[cfg(windows)]
#[inline]
fn get_internal() -> usize {
unsafe { windows_sys::Win32::System::Threading::GetCurrentThreadId() as usize }
}
#[cfg(all(
target_arch = "wasm32",
target_vendor = "unknown",
target_os = "unknown",
not(target_feature = "atomics"),
))]
#[inline]
fn get_internal() -> usize {
0
}
#[cfg(any(
target_env = "sgx",
all(
target_arch = "wasm32",
target_vendor = "unknown",
target_os = "unknown",
target_feature = "atomics",
)
))]
#[inline]
fn get_internal() -> usize {
use std::sync::atomic::{AtomicUsize, Ordering};
static COUNTER: AtomicUsize = AtomicUsize::new(0);
thread_local! {
static ID: usize = COUNTER.fetch_add(1, Ordering::Relaxed);
}
ID.with(|id| *id)
}
#[test]
fn distinct_threads_have_distinct_ids() {
use std::sync::mpsc;
use std::thread;
let (tx, rx) = mpsc::channel();
thread::spawn(move || tx.send(crate::get()).unwrap()).join().unwrap();
let main_tid = crate::get();
let other_tid = rx.recv().unwrap();
assert!(main_tid != other_tid);
}