When should I use std::thread::Builder instead of std::thread::spawn?

Question

After reading these std::thread::Builder and std::thread::spawn I understand their differences (more or less), but is it recommended to use always std::thread::Builder?.

I do not understand why there are two; can someone explain to me when is best to use one or the other? Perhaps one or the other cannot or should not be used in some cases?

---

let child: std::thread::JoinHandle<()> = std::thread::spawn(move || {
      for a in 0..100{
        println!("D");   
        std::thread::sleep(std::time::Duration::from_millis(50));
    }
});

child.join();

---

let child: Result<std::thread::JoinHandle<()>,_> = std::thread::Builder::new().name("child1".to_string()).spawn(move || {
    for a in 0..100{
        println!("D");   
        std::thread::sleep(std::time::Duration::from_millis(50));
    }
});

child.unwrap().join();

Answer 1

The documentation for thread::Builder answers all of your questions by listing all the functions and types that don't directly correspond to thread::spawn:

fn name(self, name: String) -> Builder

Names the thread-to-be. Currently the name is used for identification only in panic messages.

fn stack_size(self, size: usize) -> Builder

Sets the size of the stack for the new thread.

fn spawn<F, T>(self, f: F) -> Result<JoinHandle<T>>
    where F: FnOnce() -> T,
          F: Send + 'static,
          T: Send + 'static

...

Unlike the spawn free function, this method yields an io::Result to capture any failure to create the thread at the OS level.

So a thread::Builder allows you to:

1. Set a thread name.
2. Set the stack size.
3. Handle an error to start the thread.

Use thread::spawn when you don't care about any of those.