Revise std::thread API to join by default

This commit is part of a series that introduces a `std::thread` API to
replace `std::task`.

In the new API, `spawn` returns a `JoinGuard`, which by default will
join the spawned thread when dropped. It can also be used to join
explicitly at any time, returning the thread's result. Alternatively,
the spawned thread can be explicitly detached (so no join takes place).

As part of this change, Rust processes now terminate when the main
thread exits, even if other detached threads are still running, moving
Rust closer to standard threading models. This new behavior may break code
that was relying on the previously implicit join-all.

In addition to the above, the new thread API also offers some built-in
support for building blocking abstractions in user space; see the module
doc for details.

Closes #18000

[breaking-change]

4 files changed, 16 insertions, 16 deletions

diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index d2a9861737d..e865bf42bd0 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -167,7 +167,7 @@ mod test {
           tx.send(vec![3u8, 4u8]);
           tx.send(vec![5u8, 6u8]);
           tx.send(vec![7u8, 8u8]);
-        });
+        }).detach();
 
         let mut reader = ChanReader::new(rx);
         let mut buf = [0u8, ..3];
@@ -210,7 +210,7 @@ mod test {
           tx.send(b"rld\nhow ".to_vec());
           tx.send(b"are you?".to_vec());
           tx.send(b"".to_vec());
-        });
+        }).detach();
 
         let mut reader = ChanReader::new(rx);
 
@@ -229,11 +229,7 @@ mod test {
         writer.write_be_u32(42).unwrap();
 
         let wanted = vec![0u8, 0u8, 0u8, 42u8];
-<<<<<<< HEAD
-        let got = match task::try(move|| { rx.recv() }) {
-=======
-        let got = match Thread::with_join(proc() { rx.recv() }).join() {
->>>>>>> Fallout from new thread API
+        let got = match Thread::spawn(move|| { rx.recv() }).join() {
             Ok(got) => got,
             Err(_) => panic!(),
         };
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 6a6d467e86c..5807a3bc466 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -105,6 +105,7 @@
 //!     # #![allow(dead_code)]
 //!     use std::io::{TcpListener, TcpStream};
 //!     use std::io::{Acceptor, Listener};
+//!     use std::thread::Thread;
 //!
 //!     let listener = TcpListener::bind("127.0.0.1:80");
 //!
@@ -119,10 +120,10 @@
 //!     for stream in acceptor.incoming() {
 //!         match stream {
 //!             Err(e) => { /* connection failed */ }
-//!             Ok(stream) => spawn(move|| {
+//!             Ok(stream) => Thread::spawn(move|| {
 //!                 // connection succeeded
 //!                 handle_client(stream)
-//!             })
+//!             }).detach()
 //!         }
 //!     }
 //!
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 0e9a93e4275..6bc952f30af 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -136,16 +136,17 @@ impl TcpStream {
     /// use std::io::timer;
     /// use std::io::TcpStream;
     /// use std::time::Duration;
+    /// use std::thread::Thread;
     ///
     /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
     /// let stream2 = stream.clone();
     ///
-    /// spawn(move|| {
+    /// Thread::spawn(move|| {
     ///     // close this stream after one second
     ///     timer::sleep(Duration::seconds(1));
     ///     let mut stream = stream2;
     ///     stream.close_read();
-    /// });
+    /// }).detach();
     ///
     /// // wait for some data, will get canceled after one second
     /// let mut buf = [0];
@@ -279,6 +280,7 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
 /// # #![allow(dead_code)]
 /// use std::io::{TcpListener, TcpStream};
 /// use std::io::{Acceptor, Listener};
+/// use std::thread::Thread;
 ///
 /// let listener = TcpListener::bind("127.0.0.1:80");
 ///
@@ -293,10 +295,10 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
 /// for stream in acceptor.incoming() {
 ///     match stream {
 ///         Err(e) => { /* connection failed */ }
-///         Ok(stream) => spawn(move|| {
+///         Ok(stream) => Thread::spawn(move|| {
 ///             // connection succeeded
 ///             handle_client(stream)
-///         })
+///         }).detach()
 ///     }
 /// }
 ///
@@ -416,11 +418,12 @@ impl TcpAcceptor {
     /// ```
     /// # #![allow(experimental)]
     /// use std::io::{TcpListener, Listener, Acceptor, EndOfFile};
+    /// use std::thread::Thread;
     ///
     /// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
     /// let a2 = a.clone();
     ///
-    /// spawn(move|| {
+    /// Thread::spawn(move|| {
     ///     let mut a2 = a2;
     ///     for socket in a2.incoming() {
     ///         match socket {
@@ -429,7 +432,7 @@ impl TcpAcceptor {
     ///             Err(e) => panic!("unexpected error: {}", e),
     ///         }
     ///     }
-    /// });
+    /// }).detach();
     ///
     /// # fn wait_for_sigint() {}
     /// // Now that our accept loop is running, wait for the program to be
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index d9acb94714b..60360a2bc64 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -698,7 +698,7 @@ impl Process {
                     Thread::spawn(move |:| {
                         let mut stream = stream;
                         tx.send(stream.read_to_end())
-                    });
+                    }).detach();
                 }
                 None => tx.send(Ok(Vec::new()))
             }