pub struct Thread { /* private fields */ }
Expand description
A handle to a thread.
Threads are represented via the Thread
type, which you can get in one of
two ways:
- By spawning a new thread, e.g., using the
thread::spawn
function, and callingthread
on theJoinHandle
. - By requesting the current thread, using the
thread::current
function.
The thread::current
function is available even for threads not spawned
by the APIs of this module.
There is usually no need to create a Thread
struct yourself, one
should instead use a function like spawn
to create new threads, see the
docs of Builder
and spawn
for more details.
Implementations§
source§impl Thread
impl Thread
sourcepub fn unpark(&self)
pub fn unpark(&self)
Atomically makes the handle’s token available if it is not already.
Every thread is equipped with some basic low-level blocking support, via
the park
function and the unpark()
method. These can be
used as a more CPU-efficient implementation of a spinlock.
See the park documentation for more details.
§Examples
use std::thread;
use std::time::Duration;
let parked_thread = thread::Builder::new()
.spawn(|| {
println!("Parking thread");
thread::park();
println!("Thread unparked");
})
.unwrap();
// Let some time pass for the thread to be spawned.
thread::sleep(Duration::from_millis(10));
println!("Unpark the thread");
parked_thread.thread().unpark();
parked_thread.join().unwrap();
Runsourcepub fn name(&self) -> Option<&str>
pub fn name(&self) -> Option<&str>
Gets the thread’s name.
For more information about named threads, see this module-level documentation.
§Examples
Threads by default have no name specified:
use std::thread;
let builder = thread::Builder::new();
let handler = builder.spawn(|| {
assert!(thread::current().name().is_none());
}).unwrap();
handler.join().unwrap();
RunThread with a specified name:
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();
Run