bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Fallout from stabilization

Browse source
This commit is contained in:
Aaron Turon 2015-02-17 15:10:25 -08:00
parent d8f8f7a58c
commit d0de2b46e9
89 changed files with 578 additions and 558 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/compiletest/runtest.rs
View file

@ -35,7 +35,7 @@ use std::env;
use std::iter::repeat; use std::iter::repeat;
use std::str; use std::str;
use std::string::String; use std::string::String;
use std::thread::Thread; use std::thread;
use std::time::Duration; use std::time::Duration;
use test::MetricMap; use test::MetricMap;
@ -447,7 +447,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
loop { loop {
//waiting 1 second for gdbserver start //waiting 1 second for gdbserver start
timer::sleep(Duration::milliseconds(1000)); timer::sleep(Duration::milliseconds(1000));
let result = Thread::scoped(move || { let result = thread::spawn(move || {
tcp::TcpStream::connect("127.0.0.1:5039").unwrap(); tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
}).join(); }).join();
if result.is_err() { if result.is_err() {

16
src/liballoc/arc.rs
View file

@ -35,14 +35,14 @@
//! //!
//! ``` //! ```
//! use std::sync::Arc; //! use std::sync::Arc;
//! use std::thread::Thread; //! use std::thread;
//! //!
//! let five = Arc::new(5); //! let five = Arc::new(5);
//! //!
//! for _ in 0..10 { //! for _ in 0..10 {
//! let five = five.clone(); //! let five = five.clone();
//! //!
//! Thread::spawn(move || { //! thread::spawn(move || {
//! println!("{:?}", five); //! println!("{:?}", five);
//! }); //! });
//! } //! }
@ -52,14 +52,14 @@
//! //!
//! ``` //! ```
//! use std::sync::{Arc, Mutex}; //! use std::sync::{Arc, Mutex};
//! use std::thread::Thread; //! use std::thread;
//! //!
//! let five = Arc::new(Mutex::new(5)); //! let five = Arc::new(Mutex::new(5));
//! //!
//! for _ in 0..10 { //! for _ in 0..10 {
//! let five = five.clone(); //! let five = five.clone();
//! //!
//! Thread::spawn(move || { //! thread::spawn(move || {
//! let mut number = five.lock().unwrap(); //! let mut number = five.lock().unwrap();
//! //!
//! *number += 1; //! *number += 1;
@ -95,7 +95,7 @@ use heap::deallocate;
/// ///
/// ```rust /// ```rust
/// use std::sync::Arc; /// use std::sync::Arc;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// fn main() { /// fn main() {
/// let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect(); /// let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
@ -104,7 +104,7 @@ use heap::deallocate;
/// for _ in 0..10 { /// for _ in 0..10 {
/// let child_numbers = shared_numbers.clone(); /// let child_numbers = shared_numbers.clone();
/// ///
/// Thread::spawn(move || { /// thread::spawn(move || {
/// let local_numbers = child_numbers.as_slice(); /// let local_numbers = child_numbers.as_slice();
/// ///
/// // Work with the local numbers /// // Work with the local numbers
@ -621,7 +621,7 @@ mod tests {
use std::option::Option::{Some, None}; use std::option::Option::{Some, None};
use std::sync::atomic; use std::sync::atomic;
use std::sync::atomic::Ordering::{Acquire, SeqCst}; use std::sync::atomic::Ordering::{Acquire, SeqCst};
use std::thread::Thread; use std::thread;
use std::vec::Vec; use std::vec::Vec;
use super::{Arc, Weak, weak_count, strong_count}; use super::{Arc, Weak, weak_count, strong_count};
use std::sync::Mutex; use std::sync::Mutex;
@ -648,7 +648,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move || { let _t = thread::spawn(move || {
let arc_v: Arc<Vec<i32>> = rx.recv().unwrap(); let arc_v: Arc<Vec<i32>> = rx.recv().unwrap();
assert_eq!((*arc_v)[3], 4); assert_eq!((*arc_v)[3], 4);
}); });

4
src/libcollections/dlist.rs
View file

@ -935,7 +935,7 @@ mod tests {
use prelude::*; use prelude::*;
use std::rand; use std::rand;
use std::hash::{self, SipHasher}; use std::hash::{self, SipHasher};
use std::thread::Thread; use std::thread;
use test::Bencher; use test::Bencher;
use test; use test;
@ -1284,7 +1284,7 @@ mod tests {
#[test] #[test]
fn test_send() { fn test_send() {
let n = list_from(&[1,2,3]); let n = list_from(&[1,2,3]);
Thread::scoped(move || { thread::spawn(move || {
check_links(&n); check_links(&n);
let a: &[_] = &[&1,&2,&3]; let a: &[_] = &[&1,&2,&3];
assert_eq!(a, n.iter().collect::<Vec<_>>()); assert_eq!(a, n.iter().collect::<Vec<_>>());

4
src/libcore/atomic.rs
View file

@ -42,13 +42,13 @@
//! ``` //! ```
//! use std::sync::Arc; //! use std::sync::Arc;
//! use std::sync::atomic::{AtomicUsize, Ordering}; //! use std::sync::atomic::{AtomicUsize, Ordering};
//! use std::thread::Thread; //! use std::thread;
//! //!
//! fn main() { //! fn main() {
//! let spinlock = Arc::new(AtomicUsize::new(1)); //! let spinlock = Arc::new(AtomicUsize::new(1));
//! //!
//! let spinlock_clone = spinlock.clone(); //! let spinlock_clone = spinlock.clone();
//! Thread::spawn(move|| { //! thread::spawn(move|| {
//! spinlock_clone.store(0, Ordering::SeqCst); //! spinlock_clone.store(0, Ordering::SeqCst);
//! }); //! });
//! //!

8
src/libcore/cell.rs
View file

@ -375,9 +375,9 @@ impl<T> RefCell<T> {
/// ///
/// ``` /// ```
/// use std::cell::RefCell; /// use std::cell::RefCell;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let result = Thread::scoped(move || { /// let result = thread::spawn(move || {
/// let c = RefCell::new(5); /// let c = RefCell::new(5);
/// let m = c.borrow_mut(); /// let m = c.borrow_mut();
/// ///
@ -436,9 +436,9 @@ impl<T> RefCell<T> {
/// ///
/// ``` /// ```
/// use std::cell::RefCell; /// use std::cell::RefCell;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let result = Thread::scoped(move || { /// let result = thread::spawn(move || {
/// let c = RefCell::new(5); /// let c = RefCell::new(5);
/// let m = c.borrow_mut(); /// let m = c.borrow_mut();
/// ///

6
src/libcoretest/finally.rs
View file

@ -11,7 +11,7 @@
#![allow(deprecated)] #![allow(deprecated)]
use core::finally::{try_finally, Finally}; use core::finally::{try_finally, Finally};
use std::thread::Thread; use std::thread;
#[test] #[test]
fn test_success() { fn test_success() {
@ -22,7 +22,7 @@ fn test_success() {
*i = 10; *i = 10;
}, },
|i| { |i| {
assert!(!Thread::panicking()); assert!(!thread::panicking());
assert_eq!(*i, 10); assert_eq!(*i, 10);
*i = 20; *i = 20;
}); });
@ -40,7 +40,7 @@ fn test_fail() {
panic!(); panic!();
}, },
|i| { |i| {
assert!(Thread::panicking()); assert!(thread::panicking());
assert_eq!(*i, 10); assert_eq!(*i, 10);
}) })
} }

2
src/librustdoc/lib.rs
View file

@ -365,7 +365,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
let cr = Path::new(cratefile); let cr = Path::new(cratefile);
info!("starting to run rustc"); info!("starting to run rustc");
let (mut krate, analysis) = std::thread::Thread::scoped(move || { let (mut krate, analysis) = std::thread::spawn(move || {
use rustc::session::config::Input; use rustc::session::config::Input;
let cr = cr; let cr = cr;

4
src/librustdoc/test.rs
View file

@ -15,7 +15,7 @@ use std::old_io::{Command, TempDir};
use std::old_io; use std::old_io;
use std::env; use std::env;
use std::str; use std::str;
use std::thread::Thread; use std::thread;
use std::thunk::Thunk; use std::thunk::Thunk;
use std::collections::{HashSet, HashMap}; use std::collections::{HashSet, HashMap};
@ -142,7 +142,7 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths,
let w1 = old_io::ChanWriter::new(tx); let w1 = old_io::ChanWriter::new(tx);
let w2 = w1.clone(); let w2 = w1.clone();
let old = old_io::stdio::set_stderr(box w1); let old = old_io::stdio::set_stderr(box w1);
Thread::spawn(move || { thread::spawn(move || {
let mut p = old_io::ChanReader::new(rx); let mut p = old_io::ChanReader::new(rx);
let mut err = match old { let mut err = match old {
Some(old) => { Some(old) => {

6
src/libstd/macros.rs
View file

@ -126,7 +126,7 @@ macro_rules! try {
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use std::thread::Thread; /// use std::thread;
/// use std::sync::mpsc; /// use std::sync::mpsc;
/// ///
/// // two placeholder functions for now /// // two placeholder functions for now
@ -136,8 +136,8 @@ macro_rules! try {
/// let (tx1, rx1) = mpsc::channel(); /// let (tx1, rx1) = mpsc::channel();
/// let (tx2, rx2) = mpsc::channel(); /// let (tx2, rx2) = mpsc::channel();
/// ///
/// Thread::spawn(move|| { long_running_task(); tx1.send(()).unwrap(); }); /// thread::spawn(move|| { long_running_task(); tx1.send(()).unwrap(); });
/// Thread::spawn(move|| { tx2.send(calculate_the_answer()).unwrap(); }); /// thread::spawn(move|| { tx2.send(calculate_the_answer()).unwrap(); });
/// ///
/// select! ( /// select! (
/// _ = rx1.recv() => println!("the long running task finished first"), /// _ = rx1.recv() => println!("the long running task finished first"),

76
src/libstd/net/tcp.rs
View file

@ -43,7 +43,7 @@ pub struct TcpStream(net_imp::TcpStream);
/// ///
/// ```no_run /// ```no_run
/// use std::net::{TcpListener, TcpStream}; /// use std::net::{TcpListener, TcpStream};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let listener = TcpListener::bind("127.0.0.1:80").unwrap(); /// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
/// ///
@ -55,7 +55,7 @@ pub struct TcpStream(net_imp::TcpStream);
/// for stream in listener.incoming() { /// for stream in listener.incoming() {
/// match stream { /// match stream {
/// Ok(stream) => { /// Ok(stream) => {
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// // connection succeeded /// // connection succeeded
/// handle_client(stream) /// handle_client(stream)
/// }); /// });
@ -217,7 +217,7 @@ mod tests {
use net::*; use net::*;
use net::test::{next_test_ip4, next_test_ip6}; use net::test::{next_test_ip4, next_test_ip6};
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
fn each_ip(f: &mut FnMut(SocketAddr)) { fn each_ip(f: &mut FnMut(SocketAddr)) {
f(next_test_ip4()); f(next_test_ip4());
@ -256,7 +256,7 @@ mod tests {
let socket_addr = next_test_ip4(); let socket_addr = next_test_ip4();
let listener = t!(TcpListener::bind(&socket_addr)); let listener = t!(TcpListener::bind(&socket_addr));
let _t = Thread::scoped(move || { let _t = thread::spawn(move || {
let mut stream = t!(TcpStream::connect(&("localhost", let mut stream = t!(TcpStream::connect(&("localhost",
socket_addr.port()))); socket_addr.port())));
t!(stream.write(&[144])); t!(stream.write(&[144]));
@ -273,7 +273,7 @@ mod tests {
let addr = next_test_ip4(); let addr = next_test_ip4();
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut stream = t!(TcpStream::connect(&("127.0.0.1", addr.port()))); let mut stream = t!(TcpStream::connect(&("127.0.0.1", addr.port())));
t!(stream.write(&[44])); t!(stream.write(&[44]));
}); });
@ -289,7 +289,7 @@ mod tests {
let addr = next_test_ip6(); let addr = next_test_ip6();
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut stream = t!(TcpStream::connect(&("::1", addr.port()))); let mut stream = t!(TcpStream::connect(&("::1", addr.port())));
t!(stream.write(&[66])); t!(stream.write(&[66]));
}); });
@ -306,7 +306,7 @@ mod tests {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut stream = t!(TcpStream::connect(&addr)); let mut stream = t!(TcpStream::connect(&addr));
t!(stream.write(&[99])); t!(stream.write(&[99]));
tx.send(t!(stream.socket_addr())).unwrap(); tx.send(t!(stream.socket_addr())).unwrap();
@ -325,7 +325,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _stream = t!(TcpStream::connect(&addr)); let _stream = t!(TcpStream::connect(&addr));
// Close // Close
}); });
@ -345,7 +345,7 @@ mod tests {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
drop(t!(TcpStream::connect(&addr))); drop(t!(TcpStream::connect(&addr)));
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
@ -371,7 +371,7 @@ mod tests {
let max = 10; let max = 10;
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
for _ in 0..max { for _ in 0..max {
let mut stream = t!(TcpStream::connect(&addr)); let mut stream = t!(TcpStream::connect(&addr));
t!(stream.write(&[99])); t!(stream.write(&[99]));
@ -393,11 +393,11 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let acceptor = acceptor; let acceptor = acceptor;
for (i, stream) in acceptor.incoming().enumerate().take(MAX) { for (i, stream) in acceptor.incoming().enumerate().take(MAX) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut stream = t!(stream); let mut stream = t!(stream);
let mut buf = [0]; let mut buf = [0];
t!(stream.read(&mut buf)); t!(stream.read(&mut buf));
@ -412,7 +412,7 @@ mod tests {
fn connect(i: usize, addr: SocketAddr) { fn connect(i: usize, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let t = Thread::scoped(move|| { let t = thread::spawn(move|| {
let mut stream = t!(TcpStream::connect(&addr)); let mut stream = t!(TcpStream::connect(&addr));
// Connect again before writing // Connect again before writing
connect(i + 1, addr); connect(i + 1, addr);
@ -428,10 +428,10 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
for stream in acceptor.incoming().take(MAX) { for stream in acceptor.incoming().take(MAX) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut stream = t!(stream); let mut stream = t!(stream);
let mut buf = [0]; let mut buf = [0];
t!(stream.read(&mut buf)); t!(stream.read(&mut buf));
@ -446,7 +446,7 @@ mod tests {
fn connect(i: usize, addr: SocketAddr) { fn connect(i: usize, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let t = Thread::scoped(move|| { let t = thread::spawn(move|| {
let mut stream = t!(TcpStream::connect(&addr)); let mut stream = t!(TcpStream::connect(&addr));
connect(i + 1, addr); connect(i + 1, addr);
t!(stream.write(&[99])); t!(stream.write(&[99]));
@ -467,7 +467,7 @@ mod tests {
let listener = t!(TcpListener::bind(&addr)); let listener = t!(TcpListener::bind(&addr));
let so_name = t!(listener.socket_addr()); let so_name = t!(listener.socket_addr());
assert_eq!(addr, so_name); assert_eq!(addr, so_name);
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
t!(listener.accept()); t!(listener.accept());
}); });
@ -481,7 +481,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let (tx, rx) = channel(); let (tx, rx) = channel();
let srv = t!(TcpListener::bind(&addr)); let srv = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut cl = t!(srv.accept()).0; let mut cl = t!(srv.accept()).0;
cl.write(&[10]).unwrap(); cl.write(&[10]).unwrap();
let mut b = [0]; let mut b = [0];
@ -517,7 +517,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
t!(TcpStream::connect(&addr)); t!(TcpStream::connect(&addr));
}); });
@ -532,7 +532,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s = t!(TcpStream::connect(&addr)); let mut s = t!(TcpStream::connect(&addr));
let mut buf = [0, 0]; let mut buf = [0, 0];
assert_eq!(s.read(&mut buf), Ok(1)); assert_eq!(s.read(&mut buf), Ok(1));
@ -545,7 +545,7 @@ mod tests {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
rx1.recv().unwrap(); rx1.recv().unwrap();
t!(s2.write(&[1])); t!(s2.write(&[1]));
@ -565,7 +565,7 @@ mod tests {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s = t!(TcpStream::connect(&addr)); let mut s = t!(TcpStream::connect(&addr));
t!(s.write(&[1])); t!(s.write(&[1]));
rx.recv().unwrap(); rx.recv().unwrap();
@ -577,7 +577,7 @@ mod tests {
let s2 = t!(s1.try_clone()); let s2 = t!(s1.try_clone());
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
let mut buf = [0, 0]; let mut buf = [0, 0];
t!(s2.read(&mut buf)); t!(s2.read(&mut buf));
@ -597,7 +597,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let acceptor = t!(TcpListener::bind(&addr)); let acceptor = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s = t!(TcpStream::connect(&addr)); let mut s = t!(TcpStream::connect(&addr));
let mut buf = [0, 1]; let mut buf = [0, 1];
t!(s.read(&mut buf)); t!(s.read(&mut buf));
@ -608,7 +608,7 @@ mod tests {
let s2 = t!(s1.try_clone()); let s2 = t!(s1.try_clone());
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
t!(s2.write(&[1])); t!(s2.write(&[1]));
done.send(()).unwrap(); done.send(()).unwrap();
@ -623,7 +623,7 @@ mod tests {
fn shutdown_smoke() { fn shutdown_smoke() {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let a = t!(TcpListener::bind(&addr)); let a = t!(TcpListener::bind(&addr));
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut c = t!(a.accept()).0; let mut c = t!(a.accept()).0;
let mut b = [0]; let mut b = [0];
assert_eq!(c.read(&mut b), Ok(0)); assert_eq!(c.read(&mut b), Ok(0));
@ -644,7 +644,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let a = t!(TcpListener::bind(&addr)); let a = t!(TcpListener::bind(&addr));
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _s = t!(a.accept()); let _s = t!(a.accept());
let _ = rx.recv(); let _ = rx.recv();
}); });
@ -682,7 +682,7 @@ mod tests {
each_ip(&mut |addr| { each_ip(&mut |addr| {
let a = t!(TcpListener::bind(&addr)); let a = t!(TcpListener::bind(&addr));
let (tx1, rx) = channel::<()>(); let (tx1, rx) = channel::<()>();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _s = t!(a.accept()); let _s = t!(a.accept());
let _ = rx.recv(); let _ = rx.recv();
}); });
@ -690,7 +690,7 @@ mod tests {
let s = t!(TcpStream::connect(&addr)); let s = t!(TcpStream::connect(&addr));
let s2 = t!(s.try_clone()); let s2 = t!(s.try_clone());
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
assert_eq!(t!(s2.read(&mut [0])), 0); assert_eq!(t!(s2.read(&mut [0])), 0);
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -713,7 +713,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (txdone, rxdone) = channel(); let (txdone, rxdone) = channel();
let txdone2 = txdone.clone(); let txdone2 = txdone.clone();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut tcp = t!(TcpStream::connect(&addr)); let mut tcp = t!(TcpStream::connect(&addr));
rx.recv().unwrap(); rx.recv().unwrap();
t!(tcp.write(&[0])); t!(tcp.write(&[0]));
@ -724,7 +724,7 @@ mod tests {
let tcp = t!(accept.accept()).0; let tcp = t!(accept.accept()).0;
let tcp2 = t!(tcp.try_clone()); let tcp2 = t!(tcp.try_clone());
let txdone3 = txdone.clone(); let txdone3 = txdone.clone();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let mut tcp2 = tcp2; let mut tcp2 = tcp2;
t!(tcp2.read(&mut [0])); t!(tcp2.read(&mut [0]));
txdone3.send(()).unwrap(); txdone3.send(()).unwrap();
@ -732,7 +732,7 @@ mod tests {
// Try to ensure that the reading clone is indeed reading // Try to ensure that the reading clone is indeed reading
for _ in 0..50 { for _ in 0..50 {
Thread::yield_now(); thread::yield_now();
} }
// clone the handle again while it's reading, then let it finish the // clone the handle again while it's reading, then let it finish the
@ -750,10 +750,10 @@ mod tests {
let a = t!(TcpListener::bind(&addr)); let a = t!(TcpListener::bind(&addr));
let a2 = t!(a.try_clone()); let a2 = t!(a.try_clone());
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(&addr); let _ = TcpStream::connect(&addr);
}); });
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(&addr); let _ = TcpStream::connect(&addr);
}); });
@ -771,17 +771,17 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
tx.send(t!(a.accept())).unwrap(); tx.send(t!(a.accept())).unwrap();
}); });
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
tx2.send(t!(a2.accept())).unwrap(); tx2.send(t!(a2.accept())).unwrap();
}); });
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(&addr); let _ = TcpStream::connect(&addr);
}); });
let _t = Thread::scoped(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(&addr); let _ = TcpStream::connect(&addr);
}); });

16
src/libstd/net/udp.rs
View file

@ -131,7 +131,7 @@ mod tests {
use net::*; use net::*;
use net::test::{next_test_ip4, next_test_ip6}; use net::test::{next_test_ip4, next_test_ip6};
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
fn each_ip(f: &mut FnMut(SocketAddr, SocketAddr)) { fn each_ip(f: &mut FnMut(SocketAddr, SocketAddr)) {
f(next_test_ip4(), next_test_ip4()); f(next_test_ip4(), next_test_ip4());
@ -164,7 +164,7 @@ mod tests {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let client = t!(UdpSocket::bind(&client_ip)); let client = t!(UdpSocket::bind(&client_ip));
rx1.recv().unwrap(); rx1.recv().unwrap();
t!(client.send_to(&[99], &server_ip)); t!(client.send_to(&[99], &server_ip));
@ -196,7 +196,7 @@ mod tests {
let sock1 = t!(UdpSocket::bind(&addr1)); let sock1 = t!(UdpSocket::bind(&addr1));
let sock2 = t!(UdpSocket::bind(&addr2)); let sock2 = t!(UdpSocket::bind(&addr2));
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut buf = [0, 0]; let mut buf = [0, 0];
assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1))); assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
assert_eq!(buf[0], 1); assert_eq!(buf[0], 1);
@ -207,7 +207,7 @@ mod tests {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx1.recv().unwrap(); rx1.recv().unwrap();
t!(sock3.send_to(&[1], &addr2)); t!(sock3.send_to(&[1], &addr2));
tx2.send(()).unwrap(); tx2.send(()).unwrap();
@ -227,7 +227,7 @@ mod tests {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
t!(sock2.send_to(&[1], &addr1)); t!(sock2.send_to(&[1], &addr1));
rx.recv().unwrap(); rx.recv().unwrap();
t!(sock2.send_to(&[2], &addr1)); t!(sock2.send_to(&[2], &addr1));
@ -237,7 +237,7 @@ mod tests {
let sock3 = t!(sock1.try_clone()); let sock3 = t!(sock1.try_clone());
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut buf = [0, 0]; let mut buf = [0, 0];
t!(sock3.recv_from(&mut buf)); t!(sock3.recv_from(&mut buf));
tx2.send(()).unwrap(); tx2.send(()).unwrap();
@ -260,7 +260,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (serv_tx, serv_rx) = channel(); let (serv_tx, serv_rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut buf = [0, 1]; let mut buf = [0, 1];
rx.recv().unwrap(); rx.recv().unwrap();
t!(sock2.recv_from(&mut buf)); t!(sock2.recv_from(&mut buf));
@ -271,7 +271,7 @@ mod tests {
let (done, rx) = channel(); let (done, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
match sock3.send_to(&[1], &addr2) { match sock3.send_to(&[1], &addr2) {
Ok(..) => { let _ = tx2.send(()); } Ok(..) => { let _ = tx2.send(()); }
Err(..) => {} Err(..) => {}

8
src/libstd/old_io/comm_adapters.rs
View file

@ -161,12 +161,12 @@ mod test {
use sync::mpsc::channel; use sync::mpsc::channel;
use super::*; use super::*;
use old_io; use old_io;
use thread::Thread; use thread;
#[test] #[test]
fn test_rx_reader() { fn test_rx_reader() {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(vec![1u8, 2u8]).unwrap(); tx.send(vec![1u8, 2u8]).unwrap();
tx.send(vec![]).unwrap(); tx.send(vec![]).unwrap();
tx.send(vec![3u8, 4u8]).unwrap(); tx.send(vec![3u8, 4u8]).unwrap();
@ -208,7 +208,7 @@ mod test {
#[test] #[test]
fn test_rx_buffer() { fn test_rx_buffer() {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(b"he".to_vec()).unwrap(); tx.send(b"he".to_vec()).unwrap();
tx.send(b"llo wo".to_vec()).unwrap(); tx.send(b"llo wo".to_vec()).unwrap();
tx.send(b"".to_vec()).unwrap(); tx.send(b"".to_vec()).unwrap();
@ -234,7 +234,7 @@ mod test {
writer.write_be_u32(42).unwrap(); writer.write_be_u32(42).unwrap();
let wanted = vec![0u8, 0u8, 0u8, 42u8]; let wanted = vec![0u8, 0u8, 0u8, 42u8];
let got = match Thread::scoped(move|| { rx.recv().unwrap() }).join() { let got = match thread::spawn(move|| { rx.recv().unwrap() }).join() {
Ok(got) => got, Ok(got) => got,
Err(_) => panic!(), Err(_) => panic!(),
}; };

4
src/libstd/old_io/mod.rs
View file

@ -124,7 +124,7 @@
//! # #![allow(dead_code)] //! # #![allow(dead_code)]
//! use std::old_io::{TcpListener, TcpStream}; //! use std::old_io::{TcpListener, TcpStream};
//! use std::old_io::{Acceptor, Listener}; //! use std::old_io::{Acceptor, Listener};
//! use std::thread::Thread; //! use std::thread;
//! //!
//! let listener = TcpListener::bind("127.0.0.1:80"); //! let listener = TcpListener::bind("127.0.0.1:80");
//! //!
@ -140,7 +140,7 @@
//! match stream { //! match stream {
//! Err(e) => { /* connection failed */ } //! Err(e) => { /* connection failed */ }
//! Ok(stream) => { //! Ok(stream) => {
//! Thread::spawn(move|| { //! thread::spawn(move|| {
//! // connection succeeded //! // connection succeeded
//! handle_client(stream) //! handle_client(stream)
//! }); //! });

54
src/libstd/old_io/net/pipe.rs
View file

@ -282,7 +282,7 @@ mod tests {
use old_io::test::*; use old_io::test::*;
use super::*; use super::*;
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
use time::Duration; use time::Duration;
pub fn smalltest<F,G>(server: F, client: G) pub fn smalltest<F,G>(server: F, client: G)
@ -294,7 +294,7 @@ mod tests {
let mut acceptor = UnixListener::bind(&path1).listen(); let mut acceptor = UnixListener::bind(&path1).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
match UnixStream::connect(&path2) { match UnixStream::connect(&path2) {
Ok(c) => client(c), Ok(c) => client(c),
Err(e) => panic!("failed connect: {}", e), Err(e) => panic!("failed connect: {}", e),
@ -389,7 +389,7 @@ mod tests {
Err(e) => panic!("failed listen: {}", e), Err(e) => panic!("failed listen: {}", e),
}; };
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0u..times { for _ in 0u..times {
let mut stream = UnixStream::connect(&path2); let mut stream = UnixStream::connect(&path2);
match stream.write(&[100]) { match stream.write(&[100]) {
@ -423,7 +423,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut acceptor = UnixListener::bind(&addr).listen(); let mut acceptor = UnixListener::bind(&addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = UnixStream::connect(&addr); let mut s = UnixStream::connect(&addr);
let mut buf = [0, 0]; let mut buf = [0, 0];
debug!("client reading"); debug!("client reading");
@ -439,7 +439,7 @@ mod tests {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
rx1.recv().unwrap(); rx1.recv().unwrap();
debug!("writer writing"); debug!("writer writing");
@ -462,7 +462,7 @@ mod tests {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = UnixStream::connect(&addr); let mut s = UnixStream::connect(&addr);
s.write(&[1]).unwrap(); s.write(&[1]).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
@ -474,7 +474,7 @@ mod tests {
let s2 = s1.clone(); let s2 = s1.clone();
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
let mut buf = [0, 0]; let mut buf = [0, 0];
s2.read(&mut buf).unwrap(); s2.read(&mut buf).unwrap();
@ -493,7 +493,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut acceptor = UnixListener::bind(&addr).listen(); let mut acceptor = UnixListener::bind(&addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = UnixStream::connect(&addr); let mut s = UnixStream::connect(&addr);
let buf = &mut [0, 1]; let buf = &mut [0, 1];
s.read(buf).unwrap(); s.read(buf).unwrap();
@ -504,7 +504,7 @@ mod tests {
let s2 = s1.clone(); let s2 = s1.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
s2.write(&[1]).unwrap(); s2.write(&[1]).unwrap();
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -551,7 +551,7 @@ mod tests {
// continue to receive any pending connections. // continue to receive any pending connections.
let (tx, rx) = channel(); let (tx, rx) = channel();
let addr2 = addr.clone(); let addr2 = addr.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(UnixStream::connect(&addr2).unwrap()).unwrap(); tx.send(UnixStream::connect(&addr2).unwrap()).unwrap();
}); });
let l = rx.recv().unwrap(); let l = rx.recv().unwrap();
@ -561,7 +561,7 @@ mod tests {
Err(ref e) if e.kind == TimedOut => {} Err(ref e) if e.kind == TimedOut => {}
Err(e) => panic!("error: {}", e), Err(e) => panic!("error: {}", e),
} }
::thread::Thread::yield_now(); ::thread::yield_now();
if i == 1000 { panic!("should have a pending connection") } if i == 1000 { panic!("should have a pending connection") }
} }
drop(l); drop(l);
@ -569,7 +569,7 @@ mod tests {
// Unset the timeout and make sure that this always blocks. // Unset the timeout and make sure that this always blocks.
a.set_timeout(None); a.set_timeout(None);
let addr2 = addr.clone(); let addr2 = addr.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(UnixStream::connect(&addr2).unwrap()); drop(UnixStream::connect(&addr2).unwrap());
}); });
a.accept().unwrap(); a.accept().unwrap();
@ -607,7 +607,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let a = UnixListener::bind(&addr).listen().unwrap(); let a = UnixListener::bind(&addr).listen().unwrap();
let (_tx, rx) = channel::<()>(); let (_tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut a = a; let mut a = a;
let _s = a.accept().unwrap(); let _s = a.accept().unwrap();
let _ = rx.recv(); let _ = rx.recv();
@ -644,7 +644,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let a = UnixListener::bind(&addr).listen().unwrap(); let a = UnixListener::bind(&addr).listen().unwrap();
let (_tx, rx) = channel::<()>(); let (_tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut a = a; let mut a = a;
let _s = a.accept().unwrap(); let _s = a.accept().unwrap();
let _ = rx.recv(); let _ = rx.recv();
@ -653,7 +653,7 @@ mod tests {
let mut s = UnixStream::connect(&addr).unwrap(); let mut s = UnixStream::connect(&addr).unwrap();
let s2 = s.clone(); let s2 = s.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
assert!(s2.read(&mut [0]).is_err()); assert!(s2.read(&mut [0]).is_err());
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -670,7 +670,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut a = UnixListener::bind(&addr).listen().unwrap(); let mut a = UnixListener::bind(&addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = UnixStream::connect(&addr).unwrap(); let mut s = UnixStream::connect(&addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert!(s.write(&[0]).is_ok()); assert!(s.write(&[0]).is_ok());
@ -708,7 +708,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut a = UnixListener::bind(&addr).listen().unwrap(); let mut a = UnixListener::bind(&addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = UnixStream::connect(&addr).unwrap(); let mut s = UnixStream::connect(&addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
let mut amt = 0; let mut amt = 0;
@ -737,7 +737,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut a = UnixListener::bind(&addr).listen().unwrap(); let mut a = UnixListener::bind(&addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = UnixStream::connect(&addr).unwrap(); let mut s = UnixStream::connect(&addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert!(s.write(&[0]).is_ok()); assert!(s.write(&[0]).is_ok());
@ -764,7 +764,7 @@ mod tests {
let addr = next_test_unix(); let addr = next_test_unix();
let mut a = UnixListener::bind(&addr).listen().unwrap(); let mut a = UnixListener::bind(&addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = UnixStream::connect(&addr).unwrap(); let mut s = UnixStream::connect(&addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert!(s.write(&[0]).is_ok()); assert!(s.write(&[0]).is_ok());
@ -774,7 +774,7 @@ mod tests {
let mut s = a.accept().unwrap(); let mut s = a.accept().unwrap();
let s2 = s.clone(); let s2 = s.clone();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
assert!(s2.read(&mut [0]).is_ok()); assert!(s2.read(&mut [0]).is_ok());
tx2.send(()).unwrap(); tx2.send(()).unwrap();
@ -796,10 +796,10 @@ mod tests {
let mut a2 = a.clone(); let mut a2 = a.clone();
let addr2 = addr.clone(); let addr2 = addr.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = UnixStream::connect(&addr2); let _ = UnixStream::connect(&addr2);
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = UnixStream::connect(&addr); let _ = UnixStream::connect(&addr);
}); });
@ -819,20 +819,20 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a; let mut a = a;
tx.send(a.accept()).unwrap() tx.send(a.accept()).unwrap()
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a2; let mut a = a2;
tx2.send(a.accept()).unwrap() tx2.send(a.accept()).unwrap()
}); });
let addr2 = addr.clone(); let addr2 = addr.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = UnixStream::connect(&addr2); let _ = UnixStream::connect(&addr2);
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = UnixStream::connect(&addr); let _ = UnixStream::connect(&addr);
}); });
@ -858,7 +858,7 @@ mod tests {
let mut a2 = a.clone(); let mut a2 = a.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a; let mut a = a;
tx.send(a.accept()).unwrap(); tx.send(a.accept()).unwrap();
}); });

128
src/libstd/old_io/net/tcp.rs
View file

@ -137,12 +137,12 @@ impl TcpStream {
/// use std::old_io::timer; /// use std::old_io::timer;
/// use std::old_io::TcpStream; /// use std::old_io::TcpStream;
/// use std::time::Duration; /// use std::time::Duration;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap(); /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
/// let stream2 = stream.clone(); /// let stream2 = stream.clone();
/// ///
/// let _t = Thread::spawn(move|| { /// let _t = thread::spawn(move|| {
/// // close this stream after one second /// // close this stream after one second
/// timer::sleep(Duration::seconds(1)); /// timer::sleep(Duration::seconds(1));
/// let mut stream = stream2; /// let mut stream = stream2;
@ -282,7 +282,7 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
/// # fn foo() { /// # fn foo() {
/// use std::old_io::{TcpListener, TcpStream}; /// use std::old_io::{TcpListener, TcpStream};
/// use std::old_io::{Acceptor, Listener}; /// use std::old_io::{Acceptor, Listener};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let listener = TcpListener::bind("127.0.0.1:80").unwrap(); /// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
/// ///
@ -298,7 +298,7 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
/// match stream { /// match stream {
/// Err(e) => { /* connection failed */ } /// Err(e) => { /* connection failed */ }
/// Ok(stream) => { /// Ok(stream) => {
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// // connection succeeded /// // connection succeeded
/// handle_client(stream) /// handle_client(stream)
/// }); /// });
@ -421,12 +421,12 @@ impl TcpAcceptor {
/// ///
/// ``` /// ```
/// use std::old_io::{TcpListener, Listener, Acceptor, EndOfFile}; /// use std::old_io::{TcpListener, Listener, Acceptor, EndOfFile};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap(); /// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
/// let a2 = a.clone(); /// let a2 = a.clone();
/// ///
/// let _t = Thread::spawn(move|| { /// let _t = thread::spawn(move|| {
/// let mut a2 = a2; /// let mut a2 = a2;
/// for socket in a2.incoming() { /// for socket in a2.incoming() {
/// match socket { /// match socket {
@ -487,7 +487,7 @@ mod test {
use prelude::v1::*; use prelude::v1::*;
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
use old_io::net::tcp::*; use old_io::net::tcp::*;
use old_io::net::ip::*; use old_io::net::ip::*;
use old_io::test::*; use old_io::test::*;
@ -520,7 +520,7 @@ mod test {
let listener = TcpListener::bind(socket_addr); let listener = TcpListener::bind(socket_addr);
let mut acceptor = listener.listen(); let mut acceptor = listener.listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(("localhost", socket_addr.port)); let mut stream = TcpStream::connect(("localhost", socket_addr.port));
stream.write(&[144]).unwrap(); stream.write(&[144]).unwrap();
}); });
@ -536,7 +536,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(("localhost", addr.port)); let mut stream = TcpStream::connect(("localhost", addr.port));
stream.write(&[64]).unwrap(); stream.write(&[64]).unwrap();
}); });
@ -552,7 +552,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(("127.0.0.1", addr.port)); let mut stream = TcpStream::connect(("127.0.0.1", addr.port));
stream.write(&[44]).unwrap(); stream.write(&[44]).unwrap();
}); });
@ -568,7 +568,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(("::1", addr.port)); let mut stream = TcpStream::connect(("::1", addr.port));
stream.write(&[66]).unwrap(); stream.write(&[66]).unwrap();
}); });
@ -584,7 +584,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write(&[99]).unwrap(); stream.write(&[99]).unwrap();
}); });
@ -600,7 +600,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write(&[99]).unwrap(); stream.write(&[99]).unwrap();
}); });
@ -616,7 +616,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
}); });
@ -632,7 +632,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
}); });
@ -648,7 +648,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
}); });
@ -672,7 +672,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
}); });
@ -697,7 +697,7 @@ mod test {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(TcpStream::connect(addr)); drop(TcpStream::connect(addr));
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
@ -722,7 +722,7 @@ mod test {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(TcpStream::connect(addr)); drop(TcpStream::connect(addr));
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
@ -747,7 +747,7 @@ mod test {
let max = 10u; let max = 10u;
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0..max { for _ in 0..max {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write(&[99]).unwrap(); stream.write(&[99]).unwrap();
@ -767,7 +767,7 @@ mod test {
let max = 10u; let max = 10u;
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0..max { for _ in 0..max {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write(&[99]).unwrap(); stream.write(&[99]).unwrap();
@ -787,11 +787,11 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let acceptor = TcpListener::bind(addr).listen(); let acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acceptor = acceptor; let mut acceptor = acceptor;
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(&mut buf).unwrap(); stream.read(&mut buf).unwrap();
@ -806,7 +806,7 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
@ -823,11 +823,11 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let acceptor = TcpListener::bind(addr).listen(); let acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acceptor = acceptor; let mut acceptor = acceptor;
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(&mut buf).unwrap(); stream.read(&mut buf).unwrap();
@ -842,7 +842,7 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
@ -859,11 +859,11 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let acceptor = TcpListener::bind(addr).listen(); let acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acceptor = acceptor; let mut acceptor = acceptor;
for stream in acceptor.incoming().take(MAX as uint) { for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(&mut buf).unwrap(); stream.read(&mut buf).unwrap();
@ -878,7 +878,7 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
@ -895,11 +895,11 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let acceptor = TcpListener::bind(addr).listen(); let acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acceptor = acceptor; let mut acceptor = acceptor;
for stream in acceptor.incoming().take(MAX as uint) { for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(&mut buf).unwrap(); stream.read(&mut buf).unwrap();
@ -914,7 +914,7 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
@ -937,7 +937,7 @@ mod test {
pub fn peer_name(addr: SocketAddr) { pub fn peer_name(addr: SocketAddr) {
let acceptor = TcpListener::bind(addr).listen(); let acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acceptor = acceptor; let mut acceptor = acceptor;
acceptor.accept().unwrap(); acceptor.accept().unwrap();
}); });
@ -972,7 +972,7 @@ mod test {
fn partial_read() { fn partial_read() {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut srv = TcpListener::bind(addr).listen().unwrap(); let mut srv = TcpListener::bind(addr).listen().unwrap();
tx.send(()).unwrap(); tx.send(()).unwrap();
let mut cl = srv.accept().unwrap(); let mut cl = srv.accept().unwrap();
@ -1009,7 +1009,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
let _stream = TcpStream::connect(addr).unwrap(); let _stream = TcpStream::connect(addr).unwrap();
// Close // Close
@ -1034,7 +1034,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = TcpStream::connect(addr); let mut s = TcpStream::connect(addr);
let mut buf = [0, 0]; let mut buf = [0, 0];
assert_eq!(s.read(&mut buf), Ok(1)); assert_eq!(s.read(&mut buf), Ok(1));
@ -1047,7 +1047,7 @@ mod test {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
rx1.recv().unwrap(); rx1.recv().unwrap();
s2.write(&[1]).unwrap(); s2.write(&[1]).unwrap();
@ -1066,7 +1066,7 @@ mod test {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = TcpStream::connect(addr); let mut s = TcpStream::connect(addr);
s.write(&[1]).unwrap(); s.write(&[1]).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
@ -1078,7 +1078,7 @@ mod test {
let s2 = s1.clone(); let s2 = s1.clone();
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
let mut buf = [0, 0]; let mut buf = [0, 0];
s2.read(&mut buf).unwrap(); s2.read(&mut buf).unwrap();
@ -1097,7 +1097,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s = TcpStream::connect(addr); let mut s = TcpStream::connect(addr);
let mut buf = [0, 1]; let mut buf = [0, 1];
s.read(&mut buf).unwrap(); s.read(&mut buf).unwrap();
@ -1108,7 +1108,7 @@ mod test {
let s2 = s1.clone(); let s2 = s1.clone();
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
s2.write(&[1]).unwrap(); s2.write(&[1]).unwrap();
done.send(()).unwrap(); done.send(()).unwrap();
@ -1122,7 +1122,7 @@ mod test {
fn shutdown_smoke() { fn shutdown_smoke() {
let addr = next_test_ip4(); let addr = next_test_ip4();
let a = TcpListener::bind(addr).unwrap().listen(); let a = TcpListener::bind(addr).unwrap().listen();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a; let mut a = a;
let mut c = a.accept().unwrap(); let mut c = a.accept().unwrap();
assert_eq!(c.read_to_end(), Ok(vec!())); assert_eq!(c.read_to_end(), Ok(vec!()));
@ -1156,7 +1156,7 @@ mod test {
// flakiness. // flakiness.
if !cfg!(target_os = "freebsd") { if !cfg!(target_os = "freebsd") {
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(TcpStream::connect(addr).unwrap()).unwrap(); tx.send(TcpStream::connect(addr).unwrap()).unwrap();
}); });
let _l = rx.recv().unwrap(); let _l = rx.recv().unwrap();
@ -1166,14 +1166,14 @@ mod test {
Err(ref e) if e.kind == TimedOut => {} Err(ref e) if e.kind == TimedOut => {}
Err(e) => panic!("error: {}", e), Err(e) => panic!("error: {}", e),
} }
::thread::Thread::yield_now(); ::thread::yield_now();
if i == 1000 { panic!("should have a pending connection") } if i == 1000 { panic!("should have a pending connection") }
} }
} }
// Unset the timeout and make sure that this always blocks. // Unset the timeout and make sure that this always blocks.
a.set_timeout(None); a.set_timeout(None);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(TcpStream::connect(addr).unwrap()); drop(TcpStream::connect(addr).unwrap());
}); });
a.accept().unwrap(); a.accept().unwrap();
@ -1184,7 +1184,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let a = TcpListener::bind(addr).listen().unwrap(); let a = TcpListener::bind(addr).listen().unwrap();
let (_tx, rx) = channel::<()>(); let (_tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut a = a; let mut a = a;
let _s = a.accept().unwrap(); let _s = a.accept().unwrap();
let _ = rx.recv().unwrap(); let _ = rx.recv().unwrap();
@ -1221,7 +1221,7 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let a = TcpListener::bind(addr).listen().unwrap(); let a = TcpListener::bind(addr).listen().unwrap();
let (_tx, rx) = channel::<()>(); let (_tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut a = a; let mut a = a;
let _s = a.accept().unwrap(); let _s = a.accept().unwrap();
let _ = rx.recv().unwrap(); let _ = rx.recv().unwrap();
@ -1230,7 +1230,7 @@ mod test {
let mut s = TcpStream::connect(addr).unwrap(); let mut s = TcpStream::connect(addr).unwrap();
let s2 = s.clone(); let s2 = s.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
assert!(s2.read(&mut [0]).is_err()); assert!(s2.read(&mut [0]).is_err());
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -1247,7 +1247,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut a = TcpListener::bind(addr).listen().unwrap(); let mut a = TcpListener::bind(addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap(); let mut s = TcpStream::connect(addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert!(s.write(&[0]).is_ok()); assert!(s.write(&[0]).is_ok());
@ -1280,7 +1280,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut a = TcpListener::bind(addr).listen().unwrap(); let mut a = TcpListener::bind(addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap(); let mut s = TcpStream::connect(addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
let mut amt = 0; let mut amt = 0;
@ -1309,7 +1309,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut a = TcpListener::bind(addr).listen().unwrap(); let mut a = TcpListener::bind(addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap(); let mut s = TcpStream::connect(addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert!(s.write(&[0]).is_ok()); assert!(s.write(&[0]).is_ok());
@ -1337,7 +1337,7 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let mut a = TcpListener::bind(addr).listen().unwrap(); let mut a = TcpListener::bind(addr).listen().unwrap();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
Thread::spawn(move|| { thread::spawn(move|| {
let mut s = TcpStream::connect(addr).unwrap(); let mut s = TcpStream::connect(addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
assert_eq!(s.write(&[0]), Ok(())); assert_eq!(s.write(&[0]), Ok(()));
@ -1347,7 +1347,7 @@ mod test {
let mut s = a.accept().unwrap(); let mut s = a.accept().unwrap();
let s2 = s.clone(); let s2 = s.clone();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut s2 = s2; let mut s2 = s2;
assert_eq!(s2.read(&mut [0]), Ok(1)); assert_eq!(s2.read(&mut [0]), Ok(1));
tx2.send(()).unwrap(); tx2.send(()).unwrap();
@ -1370,7 +1370,7 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (txdone, rxdone) = channel(); let (txdone, rxdone) = channel();
let txdone2 = txdone.clone(); let txdone2 = txdone.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut tcp = TcpStream::connect(addr).unwrap(); let mut tcp = TcpStream::connect(addr).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
tcp.write_u8(0).unwrap(); tcp.write_u8(0).unwrap();
@ -1381,7 +1381,7 @@ mod test {
let tcp = accept.accept().unwrap(); let tcp = accept.accept().unwrap();
let tcp2 = tcp.clone(); let tcp2 = tcp.clone();
let txdone3 = txdone.clone(); let txdone3 = txdone.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut tcp2 = tcp2; let mut tcp2 = tcp2;
tcp2.read_u8().unwrap(); tcp2.read_u8().unwrap();
txdone3.send(()).unwrap(); txdone3.send(()).unwrap();
@ -1389,7 +1389,7 @@ mod test {
// Try to ensure that the reading clone is indeed reading // Try to ensure that the reading clone is indeed reading
for _ in 0..50 { for _ in 0..50 {
::thread::Thread::yield_now(); ::thread::yield_now();
} }
// clone the handle again while it's reading, then let it finish the // clone the handle again while it's reading, then let it finish the
@ -1407,10 +1407,10 @@ mod test {
let mut a = l.listen().unwrap(); let mut a = l.listen().unwrap();
let mut a2 = a.clone(); let mut a2 = a.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(addr); let _ = TcpStream::connect(addr);
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(addr); let _ = TcpStream::connect(addr);
}); });
@ -1428,19 +1428,19 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a; let mut a = a;
tx.send(a.accept()).unwrap(); tx.send(a.accept()).unwrap();
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a2; let mut a = a2;
tx2.send(a.accept()).unwrap(); tx2.send(a.accept()).unwrap();
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(addr); let _ = TcpStream::connect(addr);
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _ = TcpStream::connect(addr); let _ = TcpStream::connect(addr);
}); });
@ -1466,7 +1466,7 @@ mod test {
let mut a2 = a.clone(); let mut a2 = a.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a; let mut a = a;
tx.send(a.accept()).unwrap(); tx.send(a.accept()).unwrap();
}); });

20
src/libstd/old_io/net/udp.rs
View file

@ -186,7 +186,7 @@ mod test {
use old_io::test::*; use old_io::test::*;
use old_io::{IoError, TimedOut, PermissionDenied, ShortWrite}; use old_io::{IoError, TimedOut, PermissionDenied, ShortWrite};
use super::*; use super::*;
use thread::Thread; use thread;
// FIXME #11530 this fails on android because tests are run as root // FIXME #11530 this fails on android because tests are run as root
#[cfg_attr(any(windows, target_os = "android"), ignore)] #[cfg_attr(any(windows, target_os = "android"), ignore)]
@ -206,7 +206,7 @@ mod test {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Ok(ref mut client) => { Ok(ref mut client) => {
rx1.recv().unwrap(); rx1.recv().unwrap();
@ -241,7 +241,7 @@ mod test {
let client_ip = next_test_ip6(); let client_ip = next_test_ip6();
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Ok(ref mut client) => { Ok(ref mut client) => {
rx.recv().unwrap(); rx.recv().unwrap();
@ -298,7 +298,7 @@ mod test {
let mut sock1 = UdpSocket::bind(addr1).unwrap(); let mut sock1 = UdpSocket::bind(addr1).unwrap();
let sock2 = UdpSocket::bind(addr2).unwrap(); let sock2 = UdpSocket::bind(addr2).unwrap();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock2 = sock2; let mut sock2 = sock2;
let mut buf = [0, 0]; let mut buf = [0, 0];
assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1))); assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
@ -310,7 +310,7 @@ mod test {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock3 = sock3; let mut sock3 = sock3;
rx1.recv().unwrap(); rx1.recv().unwrap();
sock3.send_to(&[1], addr2).unwrap(); sock3.send_to(&[1], addr2).unwrap();
@ -331,7 +331,7 @@ mod test {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock2 = sock2; let mut sock2 = sock2;
sock2.send_to(&[1], addr1).unwrap(); sock2.send_to(&[1], addr1).unwrap();
rx.recv().unwrap(); rx.recv().unwrap();
@ -342,7 +342,7 @@ mod test {
let sock3 = sock1.clone(); let sock3 = sock1.clone();
let (done, rx) = channel(); let (done, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock3 = sock3; let mut sock3 = sock3;
let mut buf = [0, 0]; let mut buf = [0, 0];
sock3.recv_from(&mut buf).unwrap(); sock3.recv_from(&mut buf).unwrap();
@ -366,7 +366,7 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (serv_tx, serv_rx) = channel(); let (serv_tx, serv_rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock2 = sock2; let mut sock2 = sock2;
let mut buf = [0, 1]; let mut buf = [0, 1];
@ -382,7 +382,7 @@ mod test {
let (done, rx) = channel(); let (done, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut sock3 = sock3; let mut sock3 = sock3;
match sock3.send_to(&[1], addr2) { match sock3.send_to(&[1], addr2) {
Ok(..) => { let _ = tx2.send(()); } Ok(..) => { let _ = tx2.send(()); }
@ -410,7 +410,7 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut a = a2; let mut a = a2;
assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1))); assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1)));
assert_eq!(a.send_to(&[0], addr1), Ok(())); assert_eq!(a.send_to(&[0], addr1), Ok(()));

4
src/libstd/old_io/pipe.rs
View file

@ -115,7 +115,7 @@ mod test {
use prelude::v1::*; use prelude::v1::*;
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
#[test] #[test]
fn partial_read() { fn partial_read() {
@ -126,7 +126,7 @@ mod test {
let out = PipeStream::open(writer); let out = PipeStream::open(writer);
let mut input = PipeStream::open(reader); let mut input = PipeStream::open(reader);
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut out = out; let mut out = out;
out.write(&[10]).unwrap(); out.write(&[10]).unwrap();
rx.recv().unwrap(); // don't close the pipe until the other read has finished rx.recv().unwrap(); // don't close the pipe until the other read has finished

10
src/libstd/old_io/process.rs
View file

@ -30,7 +30,7 @@ use sync::mpsc::{channel, Receiver};
use sys::fs::FileDesc; use sys::fs::FileDesc;
use sys::process::Process as ProcessImp; use sys::process::Process as ProcessImp;
use sys; use sys;
use thread::Thread; use thread;
#[cfg(windows)] use hash; #[cfg(windows)] use hash;
#[cfg(windows)] use str; #[cfg(windows)] use str;
@ -703,7 +703,7 @@ impl Process {
let (tx, rx) = channel(); let (tx, rx) = channel();
match stream { match stream {
Some(stream) => { Some(stream) => {
Thread::spawn(move || { thread::spawn(move || {
let mut stream = stream; let mut stream = stream;
tx.send(stream.read_to_end()).unwrap(); tx.send(stream.read_to_end()).unwrap();
}); });
@ -764,7 +764,7 @@ mod tests {
use super::{CreatePipe}; use super::{CreatePipe};
use super::{InheritFd, Process, PleaseExitSignal, Command, ProcessOutput}; use super::{InheritFd, Process, PleaseExitSignal, Command, ProcessOutput};
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
use time::Duration; use time::Duration;
// FIXME(#10380) these tests should not all be ignored on android. // FIXME(#10380) these tests should not all be ignored on android.
@ -1169,14 +1169,14 @@ mod tests {
fn wait_timeout2() { fn wait_timeout2() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut p = sleeper(); let mut p = sleeper();
p.set_timeout(Some(10)); p.set_timeout(Some(10));
assert_eq!(p.wait().err().unwrap().kind, TimedOut); assert_eq!(p.wait().err().unwrap().kind, TimedOut);
p.signal_kill().unwrap(); p.signal_kill().unwrap();
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut p = sleeper(); let mut p = sleeper();
p.set_timeout(Some(10)); p.set_timeout(Some(10));
assert_eq!(p.wait().err().unwrap().kind, TimedOut); assert_eq!(p.wait().err().unwrap().kind, TimedOut);

6
src/libstd/old_io/stdio.rs
View file

@ -530,7 +530,7 @@ mod tests {
use super::*; use super::*;
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
#[test] #[test]
fn smoke() { fn smoke() {
@ -546,7 +546,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
set_stdout(box w); set_stdout(box w);
println!("hello!"); println!("hello!");
}); });
@ -559,7 +559,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
let _t = Thread::spawn(move || -> () { let _t = thread::spawn(move || -> () {
set_stderr(box w); set_stderr(box w);
panic!("my special message"); panic!("my special message");
}); });

10
src/libstd/old_io/timer.rs
View file

@ -224,13 +224,13 @@ fn in_ms_u64(d: Duration) -> u64 {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::Timer; use super::Timer;
use thread::Thread; use thread;
use time::Duration; use time::Duration;
#[test] #[test]
fn test_timer_send() { fn test_timer_send() {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
Thread::spawn(move || timer.sleep(Duration::milliseconds(1))); thread::spawn(move || timer.sleep(Duration::milliseconds(1)));
} }
#[test] #[test]
@ -360,7 +360,7 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_rx = timer.periodic(Duration::milliseconds(1000)); let timer_rx = timer.periodic(Duration::milliseconds(1000));
Thread::spawn(move|| { thread::spawn(move|| {
let _ = timer_rx.recv(); let _ = timer_rx.recv();
}); });
@ -374,7 +374,7 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_rx = timer.periodic(Duration::milliseconds(1000)); let timer_rx = timer.periodic(Duration::milliseconds(1000));
Thread::spawn(move|| { thread::spawn(move|| {
let _ = timer_rx.recv(); let _ = timer_rx.recv();
}); });
@ -387,7 +387,7 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_rx = timer.periodic(Duration::milliseconds(1000)); let timer_rx = timer.periodic(Duration::milliseconds(1000));
Thread::spawn(move|| { thread::spawn(move|| {
let _ = timer_rx.recv(); let _ = timer_rx.recv();
}); });

8
src/libstd/old_path/posix.rs
View file

@ -518,18 +518,18 @@ mod tests {
#[test] #[test]
fn test_null_byte() { fn test_null_byte() {
use thread::Thread; use thread;
let result = Thread::scoped(move|| { let result = thread::spawn(move|| {
Path::new(b"foo/bar\0") Path::new(b"foo/bar\0")
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());
let result = Thread::scoped(move|| { let result = thread::spawn(move|| {
Path::new("test").set_filename(b"f\0o") Path::new("test").set_filename(b"f\0o")
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());
let result = Thread::scoped(move|| { let result = thread::spawn(move|| {
Path::new("test").push(b"f\0o"); Path::new("test").push(b"f\0o");
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());

8
src/libstd/old_path/windows.rs
View file

@ -1305,18 +1305,18 @@ mod tests {
#[test] #[test]
fn test_null_byte() { fn test_null_byte() {
use thread::Thread; use thread;
let result = Thread::scoped(move|| { let result = thread::spawn(move|| {
Path::new(b"foo/bar\0") Path::new(b"foo/bar\0")
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());
let result = Thread::scoped(move|| { let result = thread::spawn(move|| {
Path::new("test").set_filename(b"f\0o") Path::new("test").set_filename(b"f\0o")
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());
let result = Thread::scoped(move || { let result = thread::spawn(move || {
Path::new("test").push(b"f\0o"); Path::new("test").push(b"f\0o");
}).join(); }).join();
assert!(result.is_err()); assert!(result.is_err());

4
src/libstd/panicking.rs
View file

@ -17,7 +17,7 @@ use cell::RefCell;
use old_io::IoResult; use old_io::IoResult;
use rt::{backtrace, unwind}; use rt::{backtrace, unwind};
use rt::util::{Stderr, Stdio}; use rt::util::{Stderr, Stdio};
use thread::Thread; use thread;
// Defined in this module instead of old_io::stdio so that the unwinding // Defined in this module instead of old_io::stdio so that the unwinding
thread_local! { thread_local! {
@ -42,7 +42,7 @@ pub fn on_panic(obj: &(Any+Send), file: &'static str, line: uint) {
} }
}; };
let mut err = Stderr; let mut err = Stderr;
let thread = Thread::current(); let thread = thread::current();
let name = thread.name().unwrap_or("<unnamed>"); let name = thread.name().unwrap_or("<unnamed>");
let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take()); let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take());
match prev { match prev {

6
src/libstd/process.rs
View file

@ -27,7 +27,7 @@ use sys::process2::Process as ProcessImp;
use sys::process2::Command as CommandImp; use sys::process2::Command as CommandImp;
use sys::process2::ExitStatus as ExitStatusImp; use sys::process2::ExitStatus as ExitStatusImp;
use sys_common::{AsInner, AsInnerMut}; use sys_common::{AsInner, AsInnerMut};
use thread::Thread; use thread;
/// Representation of a running or exited child process. /// Representation of a running or exited child process.
/// ///
@ -462,7 +462,7 @@ impl Child {
let (tx, rx) = channel(); let (tx, rx) = channel();
match stream { match stream {
Some(stream) => { Some(stream) => {
Thread::spawn(move || { thread::spawn(move || {
let mut stream = stream; let mut stream = stream;
let mut ret = Vec::new(); let mut ret = Vec::new();
let res = stream.read_to_end(&mut ret); let res = stream.read_to_end(&mut ret);
@ -499,7 +499,7 @@ mod tests {
use str; use str;
use super::{Child, Command, Output, ExitStatus, Stdio}; use super::{Child, Command, Output, ExitStatus, Stdio};
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
use time::Duration; use time::Duration;
// FIXME(#10380) these tests should not all be ignored on android. // FIXME(#10380) these tests should not all be ignored on android.

12
src/libstd/rand/os.rs
View file

@ -360,7 +360,7 @@ mod test {
use sync::mpsc::channel; use sync::mpsc::channel;
use rand::Rng; use rand::Rng;
use super::OsRng; use super::OsRng;
use thread::Thread; use thread;
#[test] #[test]
fn test_os_rng() { fn test_os_rng() {
@ -381,23 +381,23 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
txs.push(tx); txs.push(tx);
Thread::spawn(move|| { thread::spawn(move|| {
// wait until all the tasks are ready to go. // wait until all the tasks are ready to go.
rx.recv().unwrap(); rx.recv().unwrap();
// deschedule to attempt to interleave things as much // deschedule to attempt to interleave things as much
// as possible (XXX: is this a good test?) // as possible (XXX: is this a good test?)
let mut r = OsRng::new().unwrap(); let mut r = OsRng::new().unwrap();
Thread::yield_now(); thread::yield_now();
let mut v = [0u8; 1000]; let mut v = [0u8; 1000];
for _ in 0u..100 { for _ in 0u..100 {
r.next_u32(); r.next_u32();
Thread::yield_now(); thread::yield_now();
r.next_u64(); r.next_u64();
Thread::yield_now(); thread::yield_now();
r.fill_bytes(&mut v); r.fill_bytes(&mut v);
Thread::yield_now(); thread::yield_now();
} }
}); });
} }

4
src/libstd/rt/util.rs
View file

@ -149,7 +149,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
} }
pub unsafe fn report_overflow() { pub unsafe fn report_overflow() {
use thread::Thread; use thread;
// See the message below for why this is not emitted to the // See the message below for why this is not emitted to the
// ^ Where did the message below go? // ^ Where did the message below go?
@ -159,5 +159,5 @@ pub unsafe fn report_overflow() {
// and the FFI call needs 2MB of stack when we just ran out. // and the FFI call needs 2MB of stack when we just ran out.
rterrln!("\nthread '{}' has overflowed its stack", rterrln!("\nthread '{}' has overflowed its stack",
Thread::current().name().unwrap_or("<unknown>")); thread::current().name().unwrap_or("<unknown>"));
} }

8
src/libstd/sync/barrier.rs
View file

@ -15,14 +15,14 @@ use sync::{Mutex, Condvar};
/// ///
/// ```rust /// ```rust
/// use std::sync::{Arc, Barrier}; /// use std::sync::{Arc, Barrier};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let barrier = Arc::new(Barrier::new(10)); /// let barrier = Arc::new(Barrier::new(10));
/// for _ in 0u..10 { /// for _ in 0u..10 {
/// let c = barrier.clone(); /// let c = barrier.clone();
/// // The same messages will be printed together. /// // The same messages will be printed together.
/// // You will NOT see any interleaving. /// // You will NOT see any interleaving.
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// println!("before wait"); /// println!("before wait");
/// c.wait(); /// c.wait();
/// println!("after wait"); /// println!("after wait");
@ -111,7 +111,7 @@ mod tests {
use sync::{Arc, Barrier}; use sync::{Arc, Barrier};
use sync::mpsc::{channel, TryRecvError}; use sync::mpsc::{channel, TryRecvError};
use thread::Thread; use thread;
#[test] #[test]
fn test_barrier() { fn test_barrier() {
@ -123,7 +123,7 @@ mod tests {
for _ in 0u..N - 1 { for _ in 0u..N - 1 {
let c = barrier.clone(); let c = barrier.clone();
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(c.wait().is_leader()).unwrap(); tx.send(c.wait().is_leader()).unwrap();
}); });
} }

16
src/libstd/sync/condvar.rs
View file

@ -38,13 +38,13 @@ use sync::{mutex, MutexGuard, PoisonError};
/// ///
/// ``` /// ```
/// use std::sync::{Arc, Mutex, Condvar}; /// use std::sync::{Arc, Mutex, Condvar};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let pair = Arc::new((Mutex::new(false), Condvar::new())); /// let pair = Arc::new((Mutex::new(false), Condvar::new()));
/// let pair2 = pair.clone(); /// let pair2 = pair.clone();
/// ///
/// // Inside of our lock, spawn a new thread, and then wait for it to start /// // Inside of our lock, spawn a new thread, and then wait for it to start
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// let &(ref lock, ref cvar) = &*pair2; /// let &(ref lock, ref cvar) = &*pair2;
/// let mut started = lock.lock().unwrap(); /// let mut started = lock.lock().unwrap();
/// *started = true; /// *started = true;
@ -353,7 +353,7 @@ mod tests {
use sync::mpsc::channel; use sync::mpsc::channel;
use sync::{StaticMutex, MUTEX_INIT, Condvar, Mutex, Arc}; use sync::{StaticMutex, MUTEX_INIT, Condvar, Mutex, Arc};
use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use thread::Thread; use thread;
use time::Duration; use time::Duration;
#[test] #[test]
@ -377,7 +377,7 @@ mod tests {
static M: StaticMutex = MUTEX_INIT; static M: StaticMutex = MUTEX_INIT;
let g = M.lock().unwrap(); let g = M.lock().unwrap();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _g = M.lock().unwrap(); let _g = M.lock().unwrap();
C.notify_one(); C.notify_one();
}); });
@ -395,7 +395,7 @@ mod tests {
for _ in 0..N { for _ in 0..N {
let data = data.clone(); let data = data.clone();
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
let &(ref lock, ref cond) = &*data; let &(ref lock, ref cond) = &*data;
let mut cnt = lock.lock().unwrap(); let mut cnt = lock.lock().unwrap();
*cnt += 1; *cnt += 1;
@ -431,7 +431,7 @@ mod tests {
let (g, _no_timeout) = C.wait_timeout(g, Duration::nanoseconds(1000)).unwrap(); let (g, _no_timeout) = C.wait_timeout(g, Duration::nanoseconds(1000)).unwrap();
// spurious wakeups mean this isn't necessarily true // spurious wakeups mean this isn't necessarily true
// assert!(!no_timeout); // assert!(!no_timeout);
let _t = Thread::spawn(move || { let _t = thread::spawn(move || {
let _g = M.lock().unwrap(); let _g = M.lock().unwrap();
C.notify_one(); C.notify_one();
}); });
@ -452,7 +452,7 @@ mod tests {
assert!(!success); assert!(!success);
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::scoped(move || { let _t = thread::spawn(move || {
rx.recv().unwrap(); rx.recv().unwrap();
let g = M.lock().unwrap(); let g = M.lock().unwrap();
S.store(1, Ordering::SeqCst); S.store(1, Ordering::SeqCst);
@ -492,7 +492,7 @@ mod tests {
static C: StaticCondvar = CONDVAR_INIT; static C: StaticCondvar = CONDVAR_INIT;
let mut g = M1.lock().unwrap(); let mut g = M1.lock().unwrap();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _g = M1.lock().unwrap(); let _g = M1.lock().unwrap();
C.notify_one(); C.notify_one();
}); });

8
src/libstd/sync/future.rs
View file

@ -38,7 +38,7 @@ use core::mem::replace;
use self::FutureState::*; use self::FutureState::*;
use sync::mpsc::{Receiver, channel}; use sync::mpsc::{Receiver, channel};
use thunk::{Thunk}; use thunk::{Thunk};
use thread::Thread; use thread;
/// A type encapsulating the result of a computation which may not be complete /// A type encapsulating the result of a computation which may not be complete
pub struct Future<A> { pub struct Future<A> {
@ -143,7 +143,7 @@ impl<A:Send> Future<A> {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move || { thread::spawn(move || {
// Don't panic if the other end has hung up // Don't panic if the other end has hung up
let _ = tx.send(blk()); let _ = tx.send(blk());
}); });
@ -157,7 +157,7 @@ mod test {
use prelude::v1::*; use prelude::v1::*;
use sync::mpsc::channel; use sync::mpsc::channel;
use sync::Future; use sync::Future;
use thread::Thread; use thread;
#[test] #[test]
fn test_from_value() { fn test_from_value() {
@ -215,7 +215,7 @@ mod test {
let expected = "schlorf"; let expected = "schlorf";
let (tx, rx) = channel(); let (tx, rx) = channel();
let f = Future::spawn(move|| { expected }); let f = Future::spawn(move|| { expected });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut f = f; let mut f = f;
tx.send(f.get()).unwrap(); tx.send(f.get()).unwrap();
}); });

6
src/libstd/sync/mpsc/blocking.rs
View file

@ -10,7 +10,7 @@
//! Generic support for building blocking abstractions. //! Generic support for building blocking abstractions.
use thread::Thread; use thread::{self, Thread};
use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering}; use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
use sync::Arc; use sync::Arc;
use marker::{Sync, Send}; use marker::{Sync, Send};
@ -40,7 +40,7 @@ impl !Sync for WaitToken {}
pub fn tokens() -> (WaitToken, SignalToken) { pub fn tokens() -> (WaitToken, SignalToken) {
let inner = Arc::new(Inner { let inner = Arc::new(Inner {
thread: Thread::current(), thread: thread::current(),
woken: ATOMIC_BOOL_INIT, woken: ATOMIC_BOOL_INIT,
}); });
let wait_token = WaitToken { let wait_token = WaitToken {
@ -80,7 +80,7 @@ impl SignalToken {
impl WaitToken { impl WaitToken {
pub fn wait(self) { pub fn wait(self) {
while !self.inner.woken.load(Ordering::SeqCst) { while !self.inner.woken.load(Ordering::SeqCst) {
Thread::park() thread::park()
} }
} }
} }

154
src/libstd/sync/mpsc/mod.rs
View file

@ -53,12 +53,12 @@
//! Simple usage: //! Simple usage:
//! //!
//! ``` //! ```
//! use std::thread::Thread; //! use std::thread;
//! use std::sync::mpsc::channel; //! use std::sync::mpsc::channel;
//! //!
//! // Create a simple streaming channel //! // Create a simple streaming channel
//! let (tx, rx) = channel(); //! let (tx, rx) = channel();
//! Thread::spawn(move|| { //! thread::spawn(move|| {
//! tx.send(10).unwrap(); //! tx.send(10).unwrap();
//! }); //! });
//! assert_eq!(rx.recv().unwrap(), 10); //! assert_eq!(rx.recv().unwrap(), 10);
@ -67,7 +67,7 @@
//! Shared usage: //! Shared usage:
//! //!
//! ``` //! ```
//! use std::thread::Thread; //! use std::thread;
//! use std::sync::mpsc::channel; //! use std::sync::mpsc::channel;
//! //!
//! // Create a shared channel that can be sent along from many threads //! // Create a shared channel that can be sent along from many threads
@ -76,7 +76,7 @@
//! let (tx, rx) = channel(); //! let (tx, rx) = channel();
//! for i in 0..10 { //! for i in 0..10 {
//! let tx = tx.clone(); //! let tx = tx.clone();
//! Thread::spawn(move|| { //! thread::spawn(move|| {
//! tx.send(i).unwrap(); //! tx.send(i).unwrap();
//! }); //! });
//! } //! }
@ -102,11 +102,11 @@
//! Synchronous channels: //! Synchronous channels:
//! //!
//! ``` //! ```
//! use std::thread::Thread; //! use std::thread;
//! use std::sync::mpsc::sync_channel; //! use std::sync::mpsc::sync_channel;
//! //!
//! let (tx, rx) = sync_channel::<int>(0); //! let (tx, rx) = sync_channel::<int>(0);
//! Thread::spawn(move|| { //! thread::spawn(move|| {
//! // This will wait for the parent task to start receiving //! // This will wait for the parent task to start receiving
//! tx.send(53).unwrap(); //! tx.send(53).unwrap();
//! }); //! });
@ -467,14 +467,14 @@ impl<T> UnsafeFlavor<T> for Receiver<T> {
/// ///
/// ``` /// ```
/// use std::sync::mpsc::channel; /// use std::sync::mpsc::channel;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// // tx is is the sending half (tx for transmission), and rx is the receiving /// // tx is is the sending half (tx for transmission), and rx is the receiving
/// // half (rx for receiving). /// // half (rx for receiving).
/// let (tx, rx) = channel(); /// let (tx, rx) = channel();
/// ///
/// // Spawn off an expensive computation /// // Spawn off an expensive computation
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// # fn expensive_computation() {} /// # fn expensive_computation() {}
/// tx.send(expensive_computation()).unwrap(); /// tx.send(expensive_computation()).unwrap();
/// }); /// });
@ -509,14 +509,14 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
/// ///
/// ``` /// ```
/// use std::sync::mpsc::sync_channel; /// use std::sync::mpsc::sync_channel;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let (tx, rx) = sync_channel(1); /// let (tx, rx) = sync_channel(1);
/// ///
/// // this returns immediately /// // this returns immediately
/// tx.send(1).unwrap(); /// tx.send(1).unwrap();
/// ///
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// // this will block until the previous message has been received /// // this will block until the previous message has been received
/// tx.send(2).unwrap(); /// tx.send(2).unwrap();
/// }); /// });
@ -1026,7 +1026,7 @@ mod test {
use std::env; use std::env;
use super::*; use super::*;
use thread::Thread; use thread;
pub fn stress_factor() -> uint { pub fn stress_factor() -> uint {
match env::var("RUST_TEST_STRESS") { match env::var("RUST_TEST_STRESS") {
@ -1069,7 +1069,7 @@ mod test {
#[test] #[test]
fn smoke_threads() { fn smoke_threads() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(1).unwrap(); tx.send(1).unwrap();
}); });
assert_eq!(rx.recv().unwrap(), 1); assert_eq!(rx.recv().unwrap(), 1);
@ -1101,7 +1101,7 @@ mod test {
#[test] #[test]
fn port_gone_concurrent() { fn port_gone_concurrent() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}); });
while tx.send(1).is_ok() {} while tx.send(1).is_ok() {}
@ -1111,7 +1111,7 @@ mod test {
fn port_gone_concurrent_shared() { fn port_gone_concurrent_shared() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}); });
while tx.send(1).is_ok() && tx2.send(1).is_ok() {} while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
@ -1136,7 +1136,7 @@ mod test {
#[test] #[test]
fn chan_gone_concurrent() { fn chan_gone_concurrent() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(1).unwrap(); tx.send(1).unwrap();
tx.send(1).unwrap(); tx.send(1).unwrap();
}); });
@ -1146,7 +1146,7 @@ mod test {
#[test] #[test]
fn stress() { fn stress() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let t = Thread::scoped(move|| { let t = thread::spawn(move|| {
for _ in 0u..10000 { tx.send(1).unwrap(); } for _ in 0u..10000 { tx.send(1).unwrap(); }
}); });
for _ in 0u..10000 { for _ in 0u..10000 {
@ -1161,7 +1161,7 @@ mod test {
static NTHREADS: uint = 8; static NTHREADS: uint = 8;
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let t = Thread::scoped(move|| { let t = thread::spawn(move|| {
for _ in 0..AMT * NTHREADS { for _ in 0..AMT * NTHREADS {
assert_eq!(rx.recv().unwrap(), 1); assert_eq!(rx.recv().unwrap(), 1);
} }
@ -1173,7 +1173,7 @@ mod test {
for _ in 0..NTHREADS { for _ in 0..NTHREADS {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
for _ in 0..AMT { tx.send(1).unwrap(); } for _ in 0..AMT { tx.send(1).unwrap(); }
}); });
} }
@ -1185,14 +1185,14 @@ mod test {
fn send_from_outside_runtime() { fn send_from_outside_runtime() {
let (tx1, rx1) = channel::<()>(); let (tx1, rx1) = channel::<()>();
let (tx2, rx2) = channel::<int>(); let (tx2, rx2) = channel::<int>();
let t1 = Thread::scoped(move|| { let t1 = thread::spawn(move|| {
tx1.send(()).unwrap(); tx1.send(()).unwrap();
for _ in 0..40 { for _ in 0..40 {
assert_eq!(rx2.recv().unwrap(), 1); assert_eq!(rx2.recv().unwrap(), 1);
} }
}); });
rx1.recv().unwrap(); rx1.recv().unwrap();
let t2 = Thread::scoped(move|| { let t2 = thread::spawn(move|| {
for _ in 0..40 { for _ in 0..40 {
tx2.send(1).unwrap(); tx2.send(1).unwrap();
} }
@ -1204,7 +1204,7 @@ mod test {
#[test] #[test]
fn recv_from_outside_runtime() { fn recv_from_outside_runtime() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let t = Thread::scoped(move|| { let t = thread::spawn(move|| {
for _ in 0..40 { for _ in 0..40 {
assert_eq!(rx.recv().unwrap(), 1); assert_eq!(rx.recv().unwrap(), 1);
} }
@ -1219,11 +1219,11 @@ mod test {
fn no_runtime() { fn no_runtime() {
let (tx1, rx1) = channel::<int>(); let (tx1, rx1) = channel::<int>();
let (tx2, rx2) = channel::<int>(); let (tx2, rx2) = channel::<int>();
let t1 = Thread::scoped(move|| { let t1 = thread::spawn(move|| {
assert_eq!(rx1.recv().unwrap(), 1); assert_eq!(rx1.recv().unwrap(), 1);
tx2.send(2).unwrap(); tx2.send(2).unwrap();
}); });
let t2 = Thread::scoped(move|| { let t2 = thread::spawn(move|| {
tx1.send(1).unwrap(); tx1.send(1).unwrap();
assert_eq!(rx2.recv().unwrap(), 2); assert_eq!(rx2.recv().unwrap(), 2);
}); });
@ -1256,7 +1256,7 @@ mod test {
#[test] #[test]
fn oneshot_single_thread_recv_chan_close() { fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic // Receiving on a closed chan will panic
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
drop(tx); drop(tx);
rx.recv().unwrap(); rx.recv().unwrap();
@ -1325,7 +1325,7 @@ mod test {
#[test] #[test]
fn oneshot_multi_task_recv_then_send() { fn oneshot_multi_task_recv_then_send() {
let (tx, rx) = channel::<Box<int>>(); let (tx, rx) = channel::<Box<int>>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
}); });
@ -1335,10 +1335,10 @@ mod test {
#[test] #[test]
fn oneshot_multi_task_recv_then_close() { fn oneshot_multi_task_recv_then_close() {
let (tx, rx) = channel::<Box<int>>(); let (tx, rx) = channel::<Box<int>>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(tx); drop(tx);
}); });
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
}).join(); }).join();
assert!(res.is_err()); assert!(res.is_err());
@ -1348,7 +1348,7 @@ mod test {
fn oneshot_multi_thread_close_stress() { fn oneshot_multi_thread_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(rx); drop(rx);
}); });
drop(tx); drop(tx);
@ -1359,10 +1359,10 @@ mod test {
fn oneshot_multi_thread_send_close_stress() { fn oneshot_multi_thread_send_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(rx); drop(rx);
}); });
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
tx.send(1).unwrap(); tx.send(1).unwrap();
}).join(); }).join();
} }
@ -1372,14 +1372,14 @@ mod test {
fn oneshot_multi_thread_recv_close_stress() { fn oneshot_multi_thread_recv_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
Thread::spawn(move|| { thread::spawn(move|| {
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}).join(); }).join();
assert!(res.is_err()); assert!(res.is_err());
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
Thread::spawn(move|| { thread::spawn(move|| {
drop(tx); drop(tx);
}); });
}); });
@ -1390,7 +1390,7 @@ mod test {
fn oneshot_multi_thread_send_recv_stress() { fn oneshot_multi_thread_send_recv_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(box 10).unwrap(); tx.send(box 10).unwrap();
}); });
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
@ -1408,7 +1408,7 @@ mod test {
fn send(tx: Sender<Box<int>>, i: int) { fn send(tx: Sender<Box<int>>, i: int) {
if i == 10 { return } if i == 10 { return }
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(box i).unwrap(); tx.send(box i).unwrap();
send(tx, i + 1); send(tx, i + 1);
}); });
@ -1417,7 +1417,7 @@ mod test {
fn recv(rx: Receiver<Box<int>>, i: int) { fn recv(rx: Receiver<Box<int>>, i: int) {
if i == 10 { return } if i == 10 { return }
Thread::spawn(move|| { thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i); assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1); recv(rx, i + 1);
}); });
@ -1439,7 +1439,7 @@ mod test {
let total = stress_factor() + 100; let total = stress_factor() + 100;
for _ in 0..total { for _ in 0..total {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
} }
@ -1454,7 +1454,7 @@ mod test {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let (total_tx, total_rx) = channel::<int>(); let (total_tx, total_rx) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acc = 0; let mut acc = 0;
for x in rx.iter() { for x in rx.iter() {
acc += x; acc += x;
@ -1474,7 +1474,7 @@ mod test {
let (tx, rx) = channel::<int>(); let (tx, rx) = channel::<int>();
let (count_tx, count_rx) = channel(); let (count_tx, count_rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut count = 0; let mut count = 0;
for x in rx.iter() { for x in rx.iter() {
if count >= 3 { if count >= 3 {
@ -1499,7 +1499,7 @@ mod test {
let (tx1, rx1) = channel::<int>(); let (tx1, rx1) = channel::<int>();
let (tx2, rx2) = channel::<()>(); let (tx2, rx2) = channel::<()>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx2.recv().unwrap(); rx2.recv().unwrap();
tx1.send(1).unwrap(); tx1.send(1).unwrap();
tx3.send(()).unwrap(); tx3.send(()).unwrap();
@ -1524,13 +1524,13 @@ mod test {
fn destroy_upgraded_shared_port_when_sender_still_active() { fn destroy_upgraded_shared_port_when_sender_still_active() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); // wait on a oneshot rx.recv().unwrap(); // wait on a oneshot
drop(rx); // destroy a shared drop(rx); // destroy a shared
tx2.send(()).unwrap(); tx2.send(()).unwrap();
}); });
// make sure the other task has gone to sleep // make sure the other task has gone to sleep
for _ in 0u..5000 { Thread::yield_now(); } for _ in 0u..5000 { thread::yield_now(); }
// upgrade to a shared chan and send a message // upgrade to a shared chan and send a message
let t = tx.clone(); let t = tx.clone();
@ -1547,7 +1547,7 @@ mod sync_tests {
use prelude::v1::*; use prelude::v1::*;
use std::env; use std::env;
use thread::Thread; use thread;
use super::*; use super::*;
pub fn stress_factor() -> uint { pub fn stress_factor() -> uint {
@ -1583,7 +1583,7 @@ mod sync_tests {
#[test] #[test]
fn smoke_threads() { fn smoke_threads() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(1).unwrap(); tx.send(1).unwrap();
}); });
assert_eq!(rx.recv().unwrap(), 1); assert_eq!(rx.recv().unwrap(), 1);
@ -1608,7 +1608,7 @@ mod sync_tests {
#[test] #[test]
fn port_gone_concurrent() { fn port_gone_concurrent() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}); });
while tx.send(1).is_ok() {} while tx.send(1).is_ok() {}
@ -1618,7 +1618,7 @@ mod sync_tests {
fn port_gone_concurrent_shared() { fn port_gone_concurrent_shared() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let tx2 = tx.clone(); let tx2 = tx.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}); });
while tx.send(1).is_ok() && tx2.send(1).is_ok() {} while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
@ -1643,7 +1643,7 @@ mod sync_tests {
#[test] #[test]
fn chan_gone_concurrent() { fn chan_gone_concurrent() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(1).unwrap(); tx.send(1).unwrap();
tx.send(1).unwrap(); tx.send(1).unwrap();
}); });
@ -1653,7 +1653,7 @@ mod sync_tests {
#[test] #[test]
fn stress() { fn stress() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
Thread::spawn(move|| { thread::spawn(move|| {
for _ in 0u..10000 { tx.send(1).unwrap(); } for _ in 0u..10000 { tx.send(1).unwrap(); }
}); });
for _ in 0u..10000 { for _ in 0u..10000 {
@ -1668,7 +1668,7 @@ mod sync_tests {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let (dtx, drx) = sync_channel::<()>(0); let (dtx, drx) = sync_channel::<()>(0);
Thread::spawn(move|| { thread::spawn(move|| {
for _ in 0..AMT * NTHREADS { for _ in 0..AMT * NTHREADS {
assert_eq!(rx.recv().unwrap(), 1); assert_eq!(rx.recv().unwrap(), 1);
} }
@ -1681,7 +1681,7 @@ mod sync_tests {
for _ in 0..NTHREADS { for _ in 0..NTHREADS {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
for _ in 0..AMT { tx.send(1).unwrap(); } for _ in 0..AMT { tx.send(1).unwrap(); }
}); });
} }
@ -1714,7 +1714,7 @@ mod sync_tests {
#[test] #[test]
fn oneshot_single_thread_recv_chan_close() { fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic // Receiving on a closed chan will panic
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
drop(tx); drop(tx);
rx.recv().unwrap(); rx.recv().unwrap();
@ -1789,7 +1789,7 @@ mod sync_tests {
#[test] #[test]
fn oneshot_multi_task_recv_then_send() { fn oneshot_multi_task_recv_then_send() {
let (tx, rx) = sync_channel::<Box<int>>(0); let (tx, rx) = sync_channel::<Box<int>>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
}); });
@ -1799,10 +1799,10 @@ mod sync_tests {
#[test] #[test]
fn oneshot_multi_task_recv_then_close() { fn oneshot_multi_task_recv_then_close() {
let (tx, rx) = sync_channel::<Box<int>>(0); let (tx, rx) = sync_channel::<Box<int>>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(tx); drop(tx);
}); });
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
}).join(); }).join();
assert!(res.is_err()); assert!(res.is_err());
@ -1812,7 +1812,7 @@ mod sync_tests {
fn oneshot_multi_thread_close_stress() { fn oneshot_multi_thread_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(rx); drop(rx);
}); });
drop(tx); drop(tx);
@ -1823,10 +1823,10 @@ mod sync_tests {
fn oneshot_multi_thread_send_close_stress() { fn oneshot_multi_thread_send_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
drop(rx); drop(rx);
}); });
let _ = Thread::scoped(move || { let _ = thread::spawn(move || {
tx.send(1).unwrap(); tx.send(1).unwrap();
}).join(); }).join();
} }
@ -1836,14 +1836,14 @@ mod sync_tests {
fn oneshot_multi_thread_recv_close_stress() { fn oneshot_multi_thread_recv_close_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let res = Thread::scoped(move|| { let res = thread::spawn(move|| {
rx.recv().unwrap(); rx.recv().unwrap();
}).join(); }).join();
assert!(res.is_err()); assert!(res.is_err());
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
Thread::spawn(move|| { thread::spawn(move|| {
drop(tx); drop(tx);
}); });
}); });
@ -1854,7 +1854,7 @@ mod sync_tests {
fn oneshot_multi_thread_send_recv_stress() { fn oneshot_multi_thread_send_recv_stress() {
for _ in 0..stress_factor() { for _ in 0..stress_factor() {
let (tx, rx) = sync_channel::<Box<int>>(0); let (tx, rx) = sync_channel::<Box<int>>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
tx.send(box 10).unwrap(); tx.send(box 10).unwrap();
}); });
assert!(rx.recv().unwrap() == box 10); assert!(rx.recv().unwrap() == box 10);
@ -1872,7 +1872,7 @@ mod sync_tests {
fn send(tx: SyncSender<Box<int>>, i: int) { fn send(tx: SyncSender<Box<int>>, i: int) {
if i == 10 { return } if i == 10 { return }
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(box i).unwrap(); tx.send(box i).unwrap();
send(tx, i + 1); send(tx, i + 1);
}); });
@ -1881,7 +1881,7 @@ mod sync_tests {
fn recv(rx: Receiver<Box<int>>, i: int) { fn recv(rx: Receiver<Box<int>>, i: int) {
if i == 10 { return } if i == 10 { return }
Thread::spawn(move|| { thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i); assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1); recv(rx, i + 1);
}); });
@ -1903,7 +1903,7 @@ mod sync_tests {
let total = stress_factor() + 100; let total = stress_factor() + 100;
for _ in 0..total { for _ in 0..total {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
} }
@ -1918,7 +1918,7 @@ mod sync_tests {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let (total_tx, total_rx) = sync_channel::<int>(0); let (total_tx, total_rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut acc = 0; let mut acc = 0;
for x in rx.iter() { for x in rx.iter() {
acc += x; acc += x;
@ -1938,7 +1938,7 @@ mod sync_tests {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let (count_tx, count_rx) = sync_channel(0); let (count_tx, count_rx) = sync_channel(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let mut count = 0; let mut count = 0;
for x in rx.iter() { for x in rx.iter() {
if count >= 3 { if count >= 3 {
@ -1963,7 +1963,7 @@ mod sync_tests {
let (tx1, rx1) = sync_channel::<int>(1); let (tx1, rx1) = sync_channel::<int>(1);
let (tx2, rx2) = sync_channel::<()>(1); let (tx2, rx2) = sync_channel::<()>(1);
let (tx3, rx3) = sync_channel::<()>(1); let (tx3, rx3) = sync_channel::<()>(1);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx2.recv().unwrap(); rx2.recv().unwrap();
tx1.send(1).unwrap(); tx1.send(1).unwrap();
tx3.send(()).unwrap(); tx3.send(()).unwrap();
@ -1988,13 +1988,13 @@ mod sync_tests {
fn destroy_upgraded_shared_port_when_sender_still_active() { fn destroy_upgraded_shared_port_when_sender_still_active() {
let (tx, rx) = sync_channel::<()>(0); let (tx, rx) = sync_channel::<()>(0);
let (tx2, rx2) = sync_channel::<()>(0); let (tx2, rx2) = sync_channel::<()>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx.recv().unwrap(); // wait on a oneshot rx.recv().unwrap(); // wait on a oneshot
drop(rx); // destroy a shared drop(rx); // destroy a shared
tx2.send(()).unwrap(); tx2.send(()).unwrap();
}); });
// make sure the other task has gone to sleep // make sure the other task has gone to sleep
for _ in 0u..5000 { Thread::yield_now(); } for _ in 0u..5000 { thread::yield_now(); }
// upgrade to a shared chan and send a message // upgrade to a shared chan and send a message
let t = tx.clone(); let t = tx.clone();
@ -2008,14 +2008,14 @@ mod sync_tests {
#[test] #[test]
fn send1() { fn send1() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { rx.recv().unwrap(); }); let _t = thread::spawn(move|| { rx.recv().unwrap(); });
assert_eq!(tx.send(1), Ok(())); assert_eq!(tx.send(1), Ok(()));
} }
#[test] #[test]
fn send2() { fn send2() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { drop(rx); }); let _t = thread::spawn(move|| { drop(rx); });
assert!(tx.send(1).is_err()); assert!(tx.send(1).is_err());
} }
@ -2023,7 +2023,7 @@ mod sync_tests {
fn send3() { fn send3() {
let (tx, rx) = sync_channel::<int>(1); let (tx, rx) = sync_channel::<int>(1);
assert_eq!(tx.send(1), Ok(())); assert_eq!(tx.send(1), Ok(()));
let _t =Thread::spawn(move|| { drop(rx); }); let _t =thread::spawn(move|| { drop(rx); });
assert!(tx.send(1).is_err()); assert!(tx.send(1).is_err());
} }
@ -2033,11 +2033,11 @@ mod sync_tests {
let tx2 = tx.clone(); let tx2 = tx.clone();
let (done, donerx) = channel(); let (done, donerx) = channel();
let done2 = done.clone(); let done2 = done.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
assert!(tx.send(1).is_err()); assert!(tx.send(1).is_err());
done.send(()).unwrap(); done.send(()).unwrap();
}); });
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
assert!(tx2.send(2).is_err()); assert!(tx2.send(2).is_err());
done2.send(()).unwrap(); done2.send(()).unwrap();
}); });
@ -2073,7 +2073,7 @@ mod sync_tests {
let (tx1, rx1) = sync_channel::<()>(3); let (tx1, rx1) = sync_channel::<()>(3);
let (tx2, rx2) = sync_channel::<()>(3); let (tx2, rx2) = sync_channel::<()>(3);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx1.recv().unwrap(); rx1.recv().unwrap();
tx2.try_send(()).unwrap(); tx2.try_send(()).unwrap();
}); });

4
src/libstd/sync/mpsc/mpsc_queue.rs
View file

@ -160,7 +160,7 @@ mod tests {
use sync::mpsc::channel; use sync::mpsc::channel;
use super::{Queue, Data, Empty, Inconsistent}; use super::{Queue, Data, Empty, Inconsistent};
use sync::Arc; use sync::Arc;
use thread::Thread; use thread;
#[test] #[test]
fn test_full() { fn test_full() {
@ -184,7 +184,7 @@ mod tests {
for _ in 0..nthreads { for _ in 0..nthreads {
let tx = tx.clone(); let tx = tx.clone();
let q = q.clone(); let q = q.clone();
Thread::spawn(move|| { thread::spawn(move|| {
for i in 0..nmsgs { for i in 0..nmsgs {
q.push(i); q.push(i);
} }

42
src/libstd/sync/mpsc/select.rs
View file

@ -347,7 +347,7 @@ impl Iterator for Packets {
mod test { mod test {
use prelude::v1::*; use prelude::v1::*;
use thread::Thread; use thread;
use sync::mpsc::*; use sync::mpsc::*;
// Don't use the libstd version so we can pull in the right Select structure // Don't use the libstd version so we can pull in the right Select structure
@ -427,11 +427,11 @@ mod test {
let (_tx2, rx2) = channel::<int>(); let (_tx2, rx2) = channel::<int>();
let (tx3, rx3) = channel::<int>(); let (tx3, rx3) = channel::<int>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0u..20 { Thread::yield_now(); } for _ in 0u..20 { thread::yield_now(); }
tx1.send(1).unwrap(); tx1.send(1).unwrap();
rx3.recv().unwrap(); rx3.recv().unwrap();
for _ in 0u..20 { Thread::yield_now(); } for _ in 0u..20 { thread::yield_now(); }
}); });
select! { select! {
@ -451,8 +451,8 @@ mod test {
let (tx2, rx2) = channel::<int>(); let (tx2, rx2) = channel::<int>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0u..20 { Thread::yield_now(); } for _ in 0u..20 { thread::yield_now(); }
tx1.send(1).unwrap(); tx1.send(1).unwrap();
tx2.send(2).unwrap(); tx2.send(2).unwrap();
rx3.recv().unwrap(); rx3.recv().unwrap();
@ -478,7 +478,7 @@ mod test {
let (tx2, rx2) = channel::<int>(); let (tx2, rx2) = channel::<int>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for i in 0..AMT { for i in 0..AMT {
if i % 2 == 0 { if i % 2 == 0 {
tx1.send(i).unwrap(); tx1.send(i).unwrap();
@ -504,7 +504,7 @@ mod test {
let (_tx2, rx2) = channel::<int>(); let (_tx2, rx2) = channel::<int>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx3.recv().unwrap(); rx3.recv().unwrap();
tx1.clone(); tx1.clone();
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty)); assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
@ -526,7 +526,7 @@ mod test {
let (_tx2, rx2) = channel::<int>(); let (_tx2, rx2) = channel::<int>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
rx3.recv().unwrap(); rx3.recv().unwrap();
tx1.clone(); tx1.clone();
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty)); assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
@ -547,7 +547,7 @@ mod test {
let (tx1, rx1) = channel::<()>(); let (tx1, rx1) = channel::<()>();
let (tx2, rx2) = channel::<()>(); let (tx2, rx2) = channel::<()>();
let (tx3, rx3) = channel::<()>(); let (tx3, rx3) = channel::<()>();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let s = Select::new(); let s = Select::new();
let mut h1 = s.handle(&rx1); let mut h1 = s.handle(&rx1);
let mut h2 = s.handle(&rx2); let mut h2 = s.handle(&rx2);
@ -557,7 +557,7 @@ mod test {
tx3.send(()).unwrap(); tx3.send(()).unwrap();
}); });
for _ in 0u..1000 { Thread::yield_now(); } for _ in 0u..1000 { thread::yield_now(); }
drop(tx1.clone()); drop(tx1.clone());
tx2.send(()).unwrap(); tx2.send(()).unwrap();
rx3.recv().unwrap(); rx3.recv().unwrap();
@ -663,14 +663,14 @@ mod test {
fn oneshot_data_waiting() { fn oneshot_data_waiting() {
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
select! { select! {
_n = rx1.recv() => {} _n = rx1.recv() => {}
} }
tx2.send(()).unwrap(); tx2.send(()).unwrap();
}); });
for _ in 0u..100 { Thread::yield_now() } for _ in 0u..100 { thread::yield_now() }
tx1.send(()).unwrap(); tx1.send(()).unwrap();
rx2.recv().unwrap(); rx2.recv().unwrap();
} }
@ -683,14 +683,14 @@ mod test {
tx1.send(()).unwrap(); tx1.send(()).unwrap();
rx1.recv().unwrap(); rx1.recv().unwrap();
rx1.recv().unwrap(); rx1.recv().unwrap();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
select! { select! {
_n = rx1.recv() => {} _n = rx1.recv() => {}
} }
tx2.send(()).unwrap(); tx2.send(()).unwrap();
}); });
for _ in 0u..100 { Thread::yield_now() } for _ in 0u..100 { thread::yield_now() }
tx1.send(()).unwrap(); tx1.send(()).unwrap();
rx2.recv().unwrap(); rx2.recv().unwrap();
} }
@ -702,14 +702,14 @@ mod test {
drop(tx1.clone()); drop(tx1.clone());
tx1.send(()).unwrap(); tx1.send(()).unwrap();
rx1.recv().unwrap(); rx1.recv().unwrap();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
select! { select! {
_n = rx1.recv() => {} _n = rx1.recv() => {}
} }
tx2.send(()).unwrap(); tx2.send(()).unwrap();
}); });
for _ in 0u..100 { Thread::yield_now() } for _ in 0u..100 { thread::yield_now() }
tx1.send(()).unwrap(); tx1.send(()).unwrap();
rx2.recv().unwrap(); rx2.recv().unwrap();
} }
@ -726,8 +726,8 @@ mod test {
#[test] #[test]
fn sync2() { fn sync2() {
let (tx, rx) = sync_channel::<int>(0); let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0u..100 { Thread::yield_now() } for _ in 0u..100 { thread::yield_now() }
tx.send(1).unwrap(); tx.send(1).unwrap();
}); });
select! { select! {
@ -739,8 +739,8 @@ mod test {
fn sync3() { fn sync3() {
let (tx1, rx1) = sync_channel::<int>(0); let (tx1, rx1) = sync_channel::<int>(0);
let (tx2, rx2): (Sender<int>, Receiver<int>) = channel(); let (tx2, rx2): (Sender<int>, Receiver<int>) = channel();
let _t = Thread::spawn(move|| { tx1.send(1).unwrap(); }); let _t = thread::spawn(move|| { tx1.send(1).unwrap(); });
let _t = Thread::spawn(move|| { tx2.send(2).unwrap(); }); let _t = thread::spawn(move|| { tx2.send(2).unwrap(); });
select! { select! {
n = rx1.recv() => { n = rx1.recv() => {
let n = n.unwrap(); let n = n.unwrap();

8
src/libstd/sync/mpsc/shared.rs
View file

@ -31,7 +31,7 @@ use sync::mpsc::mpsc_queue as mpsc;
use sync::mpsc::select::StartResult::*; use sync::mpsc::select::StartResult::*;
use sync::mpsc::select::StartResult; use sync::mpsc::select::StartResult;
use sync::{Mutex, MutexGuard}; use sync::{Mutex, MutexGuard};
use thread::Thread; use thread;
const DISCONNECTED: isize = isize::MIN; const DISCONNECTED: isize = isize::MIN;
const FUDGE: isize = 1024; const FUDGE: isize = 1024;
@ -194,7 +194,7 @@ impl<T: Send> Packet<T> {
match self.queue.pop() { match self.queue.pop() {
mpsc::Data(..) => {} mpsc::Data(..) => {}
mpsc::Empty => break, mpsc::Empty => break,
mpsc::Inconsistent => Thread::yield_now(), mpsc::Inconsistent => thread::yield_now(),
} }
} }
// maybe we're done, if we're not the last ones // maybe we're done, if we're not the last ones
@ -283,7 +283,7 @@ impl<T: Send> Packet<T> {
mpsc::Inconsistent => { mpsc::Inconsistent => {
let data; let data;
loop { loop {
Thread::yield_now(); thread::yield_now();
match self.queue.pop() { match self.queue.pop() {
mpsc::Data(t) => { data = t; break } mpsc::Data(t) => { data = t; break }
mpsc::Empty => panic!("inconsistent => empty"), mpsc::Empty => panic!("inconsistent => empty"),
@ -460,7 +460,7 @@ impl<T: Send> Packet<T> {
drop(self.take_to_wake()); drop(self.take_to_wake());
} else { } else {
while self.to_wake.load(Ordering::SeqCst) != 0 { while self.to_wake.load(Ordering::SeqCst) != 0 {
Thread::yield_now(); thread::yield_now();
} }
} }
// if the number of steals is -1, it was the pre-emptive -1 steal // if the number of steals is -1, it was the pre-emptive -1 steal

4
src/libstd/sync/mpsc/spsc_queue.rs
View file

@ -246,7 +246,7 @@ mod test {
use sync::Arc; use sync::Arc;
use super::Queue; use super::Queue;
use thread::Thread; use thread;
use sync::mpsc::channel; use sync::mpsc::channel;
#[test] #[test]
@ -324,7 +324,7 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
let q2 = q.clone(); let q2 = q.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
for _ in 0u..100000 { for _ in 0u..100000 {
loop { loop {
match q2.pop() { match q2.pop() {

4
src/libstd/sync/mpsc/stream.rs
View file

@ -26,7 +26,7 @@ use core::prelude::*;
use core::cmp; use core::cmp;
use core::isize; use core::isize;
use thread::Thread; use thread;
use sync::atomic::{AtomicIsize, AtomicUsize, Ordering, AtomicBool}; use sync::atomic::{AtomicIsize, AtomicUsize, Ordering, AtomicBool};
use sync::mpsc::Receiver; use sync::mpsc::Receiver;
@ -440,7 +440,7 @@ impl<T: Send> Packet<T> {
drop(self.take_to_wake()); drop(self.take_to_wake());
} else { } else {
while self.to_wake.load(Ordering::SeqCst) != 0 { while self.to_wake.load(Ordering::SeqCst) != 0 {
Thread::yield_now(); thread::yield_now();
} }
} }
assert_eq!(self.steals, 0); assert_eq!(self.steals, 0);

24
src/libstd/sync/mutex.rs
View file

@ -47,7 +47,7 @@ use sys_common::mutex as sys;
/// ///
/// ```rust /// ```rust
/// use std::sync::{Arc, Mutex}; /// use std::sync::{Arc, Mutex};
/// use std::thread::Thread; /// use std::thread;
/// use std::sync::mpsc::channel; /// use std::sync::mpsc::channel;
/// ///
/// const N: uint = 10; /// const N: uint = 10;
@ -62,7 +62,7 @@ use sys_common::mutex as sys;
/// let (tx, rx) = channel(); /// let (tx, rx) = channel();
/// for _ in 0u..10 { /// for _ in 0u..10 {
/// let (data, tx) = (data.clone(), tx.clone()); /// let (data, tx) = (data.clone(), tx.clone());
/// Thread::spawn(move || { /// thread::spawn(move || {
/// // The shared static can only be accessed once the lock is held. /// // The shared static can only be accessed once the lock is held.
/// // Our non-atomic increment is safe because we're the only thread /// // Our non-atomic increment is safe because we're the only thread
/// // which can access the shared state when the lock is held. /// // which can access the shared state when the lock is held.
@ -85,12 +85,12 @@ use sys_common::mutex as sys;
/// ///
/// ```rust /// ```rust
/// use std::sync::{Arc, Mutex}; /// use std::sync::{Arc, Mutex};
/// use std::thread::Thread; /// use std::thread;
/// ///
/// let lock = Arc::new(Mutex::new(0u)); /// let lock = Arc::new(Mutex::new(0u));
/// let lock2 = lock.clone(); /// let lock2 = lock.clone();
/// ///
/// let _ = Thread::scoped(move || -> () { /// let _ = thread::spawn(move || -> () {
/// // This thread will acquire the mutex first, unwrapping the result of /// // This thread will acquire the mutex first, unwrapping the result of
/// // `lock` because the lock has not been poisoned. /// // `lock` because the lock has not been poisoned.
/// let _lock = lock2.lock().unwrap(); /// let _lock = lock2.lock().unwrap();
@ -350,7 +350,7 @@ mod test {
use sync::mpsc::channel; use sync::mpsc::channel;
use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar}; use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar};
use thread::Thread; use thread;
struct Packet<T>(Arc<(Mutex<T>, Condvar)>); struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
@ -393,9 +393,9 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
for _ in 0..K { for _ in 0..K {
let tx2 = tx.clone(); let tx2 = tx.clone();
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }); thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
let tx2 = tx.clone(); let tx2 = tx.clone();
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }); thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
} }
drop(tx); drop(tx);
@ -419,7 +419,7 @@ mod test {
let packet = Packet(Arc::new((Mutex::new(false), Condvar::new()))); let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
let packet2 = Packet(packet.0.clone()); let packet2 = Packet(packet.0.clone());
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
// wait until parent gets in // wait until parent gets in
rx.recv().unwrap(); rx.recv().unwrap();
let &(ref lock, ref cvar) = &*packet2.0; let &(ref lock, ref cvar) = &*packet2.0;
@ -443,7 +443,7 @@ mod test {
let packet2 = Packet(packet.0.clone()); let packet2 = Packet(packet.0.clone());
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move || -> () { let _t = thread::spawn(move || -> () {
rx.recv().unwrap(); rx.recv().unwrap();
let &(ref lock, ref cvar) = &*packet2.0; let &(ref lock, ref cvar) = &*packet2.0;
let _g = lock.lock().unwrap(); let _g = lock.lock().unwrap();
@ -471,7 +471,7 @@ mod test {
let arc = Arc::new(Mutex::new(1)); let arc = Arc::new(Mutex::new(1));
assert!(!arc.is_poisoned()); assert!(!arc.is_poisoned());
let arc2 = arc.clone(); let arc2 = arc.clone();
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
let lock = arc2.lock().unwrap(); let lock = arc2.lock().unwrap();
assert_eq!(*lock, 2); assert_eq!(*lock, 2);
}).join(); }).join();
@ -486,7 +486,7 @@ mod test {
let arc = Arc::new(Mutex::new(1)); let arc = Arc::new(Mutex::new(1));
let arc2 = Arc::new(Mutex::new(arc)); let arc2 = Arc::new(Mutex::new(arc));
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let lock = arc2.lock().unwrap(); let lock = arc2.lock().unwrap();
let lock2 = lock.lock().unwrap(); let lock2 = lock.lock().unwrap();
assert_eq!(*lock2, 1); assert_eq!(*lock2, 1);
@ -499,7 +499,7 @@ mod test {
fn test_mutex_arc_access_in_unwind() { fn test_mutex_arc_access_in_unwind() {
let arc = Arc::new(Mutex::new(1)); let arc = Arc::new(Mutex::new(1));
let arc2 = arc.clone(); let arc2 = arc.clone();
let _ = Thread::scoped(move|| -> () { let _ = thread::spawn(move|| -> () {
struct Unwinder { struct Unwinder {
i: Arc<Mutex<int>>, i: Arc<Mutex<int>>,
} }

6
src/libstd/sync/once.rs
View file

@ -127,7 +127,7 @@ impl Once {
mod test { mod test {
use prelude::v1::*; use prelude::v1::*;
use thread::Thread; use thread;
use super::{ONCE_INIT, Once}; use super::{ONCE_INIT, Once};
use sync::mpsc::channel; use sync::mpsc::channel;
@ -149,8 +149,8 @@ mod test {
let (tx, rx) = channel(); let (tx, rx) = channel();
for _ in 0u..10 { for _ in 0u..10 {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
for _ in 0u..4 { Thread::yield_now() } for _ in 0u..4 { thread::yield_now() }
unsafe { unsafe {
O.call_once(|| { O.call_once(|| {
assert!(!run); assert!(!run);

6
src/libstd/sync/poison.rs
View file

@ -13,7 +13,7 @@ use prelude::v1::*;
use cell::UnsafeCell; use cell::UnsafeCell;
use error::{Error, FromError}; use error::{Error, FromError};
use fmt; use fmt;
use thread::Thread; use thread;
pub struct Flag { failed: UnsafeCell<bool> } pub struct Flag { failed: UnsafeCell<bool> }
pub const FLAG_INIT: Flag = Flag { failed: UnsafeCell { value: false } }; pub const FLAG_INIT: Flag = Flag { failed: UnsafeCell { value: false } };
@ -21,7 +21,7 @@ pub const FLAG_INIT: Flag = Flag { failed: UnsafeCell { value: false } };
impl Flag { impl Flag {
#[inline] #[inline]
pub fn borrow(&self) -> LockResult<Guard> { pub fn borrow(&self) -> LockResult<Guard> {
let ret = Guard { panicking: Thread::panicking() }; let ret = Guard { panicking: thread::panicking() };
if unsafe { *self.failed.get() } { if unsafe { *self.failed.get() } {
Err(PoisonError::new(ret)) Err(PoisonError::new(ret))
} else { } else {
@ -31,7 +31,7 @@ impl Flag {
#[inline] #[inline]
pub fn done(&self, guard: &Guard) { pub fn done(&self, guard: &Guard) {
if !guard.panicking && Thread::panicking() { if !guard.panicking && thread::panicking() {
unsafe { *self.failed.get() = true; } unsafe { *self.failed.get() = true; }
} }
} }

20
src/libstd/sync/rwlock.rs
View file

@ -400,7 +400,7 @@ mod tests {
use rand::{self, Rng}; use rand::{self, Rng};
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
use sync::{Arc, RwLock, StaticRwLock, RW_LOCK_INIT}; use sync::{Arc, RwLock, StaticRwLock, RW_LOCK_INIT};
#[test] #[test]
@ -431,7 +431,7 @@ mod tests {
let (tx, rx) = channel::<()>(); let (tx, rx) = channel::<()>();
for _ in 0..N { for _ in 0..N {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
for _ in 0..M { for _ in 0..M {
if rng.gen_weighted_bool(N) { if rng.gen_weighted_bool(N) {
@ -452,7 +452,7 @@ mod tests {
fn test_rw_arc_poison_wr() { fn test_rw_arc_poison_wr() {
let arc = Arc::new(RwLock::new(1)); let arc = Arc::new(RwLock::new(1));
let arc2 = arc.clone(); let arc2 = arc.clone();
let _: Result<uint, _> = Thread::scoped(move|| { let _: Result<uint, _> = thread::spawn(move|| {
let _lock = arc2.write().unwrap(); let _lock = arc2.write().unwrap();
panic!(); panic!();
}).join(); }).join();
@ -464,7 +464,7 @@ mod tests {
let arc = Arc::new(RwLock::new(1)); let arc = Arc::new(RwLock::new(1));
assert!(!arc.is_poisoned()); assert!(!arc.is_poisoned());
let arc2 = arc.clone(); let arc2 = arc.clone();
let _: Result<uint, _> = Thread::scoped(move|| { let _: Result<uint, _> = thread::spawn(move|| {
let _lock = arc2.write().unwrap(); let _lock = arc2.write().unwrap();
panic!(); panic!();
}).join(); }).join();
@ -476,7 +476,7 @@ mod tests {
fn test_rw_arc_no_poison_rr() { fn test_rw_arc_no_poison_rr() {
let arc = Arc::new(RwLock::new(1)); let arc = Arc::new(RwLock::new(1));
let arc2 = arc.clone(); let arc2 = arc.clone();
let _: Result<uint, _> = Thread::scoped(move|| { let _: Result<uint, _> = thread::spawn(move|| {
let _lock = arc2.read().unwrap(); let _lock = arc2.read().unwrap();
panic!(); panic!();
}).join(); }).join();
@ -487,7 +487,7 @@ mod tests {
fn test_rw_arc_no_poison_rw() { fn test_rw_arc_no_poison_rw() {
let arc = Arc::new(RwLock::new(1)); let arc = Arc::new(RwLock::new(1));
let arc2 = arc.clone(); let arc2 = arc.clone();
let _: Result<uint, _> = Thread::scoped(move|| { let _: Result<uint, _> = thread::spawn(move|| {
let _lock = arc2.read().unwrap(); let _lock = arc2.read().unwrap();
panic!() panic!()
}).join(); }).join();
@ -501,12 +501,12 @@ mod tests {
let arc2 = arc.clone(); let arc2 = arc.clone();
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
let mut lock = arc2.write().unwrap(); let mut lock = arc2.write().unwrap();
for _ in 0u..10 { for _ in 0u..10 {
let tmp = *lock; let tmp = *lock;
*lock = -1; *lock = -1;
Thread::yield_now(); thread::yield_now();
*lock = tmp + 1; *lock = tmp + 1;
} }
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -516,7 +516,7 @@ mod tests {
let mut children = Vec::new(); let mut children = Vec::new();
for _ in 0u..5 { for _ in 0u..5 {
let arc3 = arc.clone(); let arc3 = arc.clone();
children.push(Thread::scoped(move|| { children.push(thread::spawn(move|| {
let lock = arc3.read().unwrap(); let lock = arc3.read().unwrap();
assert!(*lock >= 0); assert!(*lock >= 0);
})); }));
@ -537,7 +537,7 @@ mod tests {
fn test_rw_arc_access_in_unwind() { fn test_rw_arc_access_in_unwind() {
let arc = Arc::new(RwLock::new(1)); let arc = Arc::new(RwLock::new(1));
let arc2 = arc.clone(); let arc2 = arc.clone();
let _ = Thread::scoped(move|| -> () { let _ = thread::spawn(move|| -> () {
struct Unwinder { struct Unwinder {
i: Arc<RwLock<int>>, i: Arc<RwLock<int>>,
} }

12
src/libstd/sync/semaphore.rs
View file

@ -114,7 +114,7 @@ mod tests {
use sync::Arc; use sync::Arc;
use super::Semaphore; use super::Semaphore;
use sync::mpsc::channel; use sync::mpsc::channel;
use thread::Thread; use thread;
#[test] #[test]
fn test_sem_acquire_release() { fn test_sem_acquire_release() {
@ -134,7 +134,7 @@ mod tests {
fn test_sem_as_mutex() { fn test_sem_as_mutex() {
let s = Arc::new(Semaphore::new(1)); let s = Arc::new(Semaphore::new(1));
let s2 = s.clone(); let s2 = s.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _g = s2.access(); let _g = s2.access();
}); });
let _g = s.access(); let _g = s.access();
@ -146,7 +146,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let s = Arc::new(Semaphore::new(0)); let s = Arc::new(Semaphore::new(0));
let s2 = s.clone(); let s2 = s.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
s2.acquire(); s2.acquire();
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
@ -157,7 +157,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
let s = Arc::new(Semaphore::new(0)); let s = Arc::new(Semaphore::new(0));
let s2 = s.clone(); let s2 = s.clone();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
s2.release(); s2.release();
let _ = rx.recv(); let _ = rx.recv();
}); });
@ -173,7 +173,7 @@ mod tests {
let s2 = s.clone(); let s2 = s.clone();
let (tx1, rx1) = channel(); let (tx1, rx1) = channel();
let (tx2, rx2) = channel(); let (tx2, rx2) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _g = s2.access(); let _g = s2.access();
let _ = rx2.recv(); let _ = rx2.recv();
tx1.send(()).unwrap(); tx1.send(()).unwrap();
@ -190,7 +190,7 @@ mod tests {
let (tx, rx) = channel(); let (tx, rx) = channel();
{ {
let _g = s.access(); let _g = s.access();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(()).unwrap(); tx.send(()).unwrap();
drop(s2.access()); drop(s2.access());
tx.send(()).unwrap(); tx.send(()).unwrap();

4
src/libstd/sync/task_pool.rs
View file

@ -20,7 +20,7 @@ use core::prelude::*;
use sync::{Arc, Mutex}; use sync::{Arc, Mutex};
use sync::mpsc::{channel, Sender, Receiver}; use sync::mpsc::{channel, Sender, Receiver};
use thread::Thread; use thread;
use thunk::Thunk; use thunk::Thunk;
struct Sentinel<'a> { struct Sentinel<'a> {
@ -112,7 +112,7 @@ impl TaskPool {
} }
fn spawn_in_pool(jobs: Arc<Mutex<Receiver<Thunk>>>) { fn spawn_in_pool(jobs: Arc<Mutex<Receiver<Thunk>>>) {
Thread::spawn(move || { thread::spawn(move || {
// Will spawn a new thread on panic unless it is cancelled. // Will spawn a new thread on panic unless it is cancelled.
let sentinel = Sentinel::new(&jobs); let sentinel = Sentinel::new(&jobs);

4
src/libstd/sys/common/helper_thread.rs
View file

@ -30,7 +30,7 @@ use sync::{StaticMutex, StaticCondvar};
use sync::mpsc::{channel, Sender, Receiver}; use sync::mpsc::{channel, Sender, Receiver};
use sys::helper_signal; use sys::helper_signal;
use thread::Thread; use thread;
/// A structure for management of a helper thread. /// A structure for management of a helper thread.
/// ///
@ -95,7 +95,7 @@ impl<M: Send> Helper<M> {
let receive = RaceBox(receive); let receive = RaceBox(receive);
let t = f(); let t = f();
Thread::spawn(move || { thread::spawn(move || {
helper(receive.0, rx, t); helper(receive.0, rx, t);
let _g = self.lock.lock().unwrap(); let _g = self.lock.lock().unwrap();
*self.shutdown.get() = true; *self.shutdown.get() = true;

4
src/libstd/sys/common/thread_info.rs
View file

@ -29,7 +29,7 @@ thread_local! { static THREAD_INFO: RefCell<Option<ThreadInfo>> = RefCell::new(N
impl ThreadInfo { impl ThreadInfo {
fn with<R, F>(f: F) -> R where F: FnOnce(&mut ThreadInfo) -> R { fn with<R, F>(f: F) -> R where F: FnOnce(&mut ThreadInfo) -> R {
if THREAD_INFO.state() == State::Destroyed { if THREAD_INFO.state() == State::Destroyed {
panic!("Use of std::thread::Thread::current() is not possible after \ panic!("Use of std::thread::current() is not possible after \
the thread's local data has been destroyed"); the thread's local data has been destroyed");
} }
@ -63,7 +63,7 @@ pub fn set(stack_bounds: (uint, uint), stack_guard: uint, thread: Thread) {
})); }));
} }
// a hack to get around privacy restrictions; implemented by `std::thread::Thread` // a hack to get around privacy restrictions; implemented by `std::thread`
pub trait NewThread { pub trait NewThread {
fn new(name: Option<String>) -> Self; fn new(name: Option<String>) -> Self;
} }

2
src/libstd/sys/common/thread_local.rs
View file

@ -24,7 +24,7 @@
//! # Usage //! # Usage
//! //!
//! This module should likely not be used directly unless other primitives are //! This module should likely not be used directly unless other primitives are
//! being built on. types such as `thread_local::scoped::Key` are likely much //! being built on. types such as `thread_local::spawn::Key` are likely much
//! more useful in practice than this OS-based version which likely requires //! more useful in practice than this OS-based version which likely requires
//! unsafe code to interoperate with. //! unsafe code to interoperate with.
//! //!

102
src/libstd/thread.rs
View file

@ -42,23 +42,23 @@
//! Already-running threads are represented via the `Thread` type, which you can //! Already-running threads are represented via the `Thread` type, which you can
//! get in one of two ways: //! get in one of two ways:
//! //!
//! * By spawning a new thread, e.g. using the `Thread::spawn` constructor; //! * By spawning a new thread, e.g. using the `thread::spawn` constructor;
//! * By requesting the current thread, using the `Thread::current` function. //! * By requesting the current thread, using the `thread::current` function.
//! //!
//! Threads can be named, and provide some built-in support for low-level //! Threads can be named, and provide some built-in support for low-level
//! synchronization described below. //! synchronization described below.
//! //!
//! The `Thread::current()` function is available even for threads not spawned //! The `thread::current()` function is available even for threads not spawned
//! by the APIs of this module. //! by the APIs of this module.
//! //!
//! ## Spawning a thread //! ## Spawning a thread
//! //!
//! A new thread can be spawned using the `Thread::spawn` function: //! A new thread can be spawned using the `thread::spawn` function:
//! //!
//! ```rust //! ```rust
//! use std::thread::Thread; //! use std::thread;
//! //!
//! Thread::spawn(move || { //! thread::spawn(move || {
//! println!("Hello, World!"); //! println!("Hello, World!");
//! // some computation here //! // some computation here
//! }); //! });
@ -76,14 +76,14 @@
//! For this scenario, use the `scoped` constructor: //! For this scenario, use the `scoped` constructor:
//! //!
//! ```rust //! ```rust
//! use std::thread::Thread; //! use std::thread;
//! //!
//! let guard = Thread::scoped(move || { //! let guard = thread::scoped(move || {
//! println!("Hello, World!"); //! println!("Hello, World!");
//! // some computation here //! // some computation here
//! }); //! });
//! // do some other work in the meantime //! // do some other work in the meantime
//! let result = guard.join(); //! let output = guard.join();
//! ``` //! ```
//! //!
//! The `scoped` function doesn't return a `Thread` directly; instead, //! The `scoped` function doesn't return a `Thread` directly; instead,
@ -120,10 +120,10 @@
//! Conceptually, each `Thread` handle has an associated token, which is //! Conceptually, each `Thread` handle has an associated token, which is
//! initially not present: //! initially not present:
//! //!
//! * The `Thread::park()` function blocks the current thread unless or until //! * The `thread::park()` function blocks the current thread unless or until
//! the token is available for its thread handle, at which point It atomically //! the token is available for its thread handle, at which point It atomically
//! consumes the token. It may also return *spuriously*, without consuming the //! consumes the token. It may also return *spuriously*, without consuming the
//! token. `Thread::park_timeout()` does the same, but allows specifying a //! token. `thread::park_timeout()` does the same, but allows specifying a
//! maximum time to block the thread for. //! maximum time to block the thread for.
//! //!
//! * The `unpark()` method on a `Thread` atomically makes the token available //! * The `unpark()` method on a `Thread` atomically makes the token available
@ -411,7 +411,7 @@ pub fn panicking() -> bool {
// or futuxes, and in either case may allow spurious wakeups. // or futuxes, and in either case may allow spurious wakeups.
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn park() { pub fn park() {
let thread = Thread::current(); let thread = current();
let mut guard = thread.inner.lock.lock().unwrap(); let mut guard = thread.inner.lock.lock().unwrap();
while !*guard { while !*guard {
guard = thread.inner.cvar.wait(guard).unwrap(); guard = thread.inner.cvar.wait(guard).unwrap();
@ -431,7 +431,7 @@ pub fn park() {
/// See the module doc for more detail. /// See the module doc for more detail.
#[unstable(feature = "std_misc", reason = "recently introduced, depends on Duration")] #[unstable(feature = "std_misc", reason = "recently introduced, depends on Duration")]
pub fn park_timeout(dur: Duration) { pub fn park_timeout(dur: Duration) {
let thread = Thread::current(); let thread = current();
let mut guard = thread.inner.lock.lock().unwrap(); let mut guard = thread.inner.lock.lock().unwrap();
if !*guard { if !*guard {
let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap(); let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap();
@ -512,7 +512,7 @@ impl Thread {
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")] #[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
#[unstable(feature = "std_misc", reason = "recently introduced")] #[unstable(feature = "std_misc", reason = "recently introduced")]
pub fn park() { pub fn park() {
let thread = Thread::current(); let thread = current();
let mut guard = thread.inner.lock.lock().unwrap(); let mut guard = thread.inner.lock.lock().unwrap();
while !*guard { while !*guard {
guard = thread.inner.cvar.wait(guard).unwrap(); guard = thread.inner.cvar.wait(guard).unwrap();
@ -524,7 +524,7 @@ impl Thread {
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")] #[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
#[unstable(feature = "std_misc", reason = "recently introduced")] #[unstable(feature = "std_misc", reason = "recently introduced")]
pub fn park_timeout(dur: Duration) { pub fn park_timeout(dur: Duration) {
let thread = Thread::current(); let thread = current();
let mut guard = thread.inner.lock.lock().unwrap(); let mut guard = thread.inner.lock.lock().unwrap();
if !*guard { if !*guard {
let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap(); let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap();
@ -700,7 +700,7 @@ mod test {
use boxed::BoxAny; use boxed::BoxAny;
use result; use result;
use std::old_io::{ChanReader, ChanWriter}; use std::old_io::{ChanReader, ChanWriter};
use super::{Thread, Builder}; use super::{self, Thread, Builder};
use thunk::Thunk; use thunk::Thunk;
use time::Duration; use time::Duration;
@ -709,22 +709,22 @@ mod test {
#[test] #[test]
fn test_unnamed_thread() { fn test_unnamed_thread() {
Thread::scoped(move|| { thread::spawn(move|| {
assert!(Thread::current().name().is_none()); assert!(thread::current().name().is_none());
}).join().ok().unwrap(); }).join().ok().unwrap();
} }
#[test] #[test]
fn test_named_thread() { fn test_named_thread() {
Builder::new().name("ada lovelace".to_string()).scoped(move|| { Builder::new().name("ada lovelace".to_string()).scoped(move|| {
assert!(Thread::current().name().unwrap() == "ada lovelace".to_string()); assert!(thread::current().name().unwrap() == "ada lovelace".to_string());
}).join().ok().unwrap(); }).join().ok().unwrap();
} }
#[test] #[test]
fn test_run_basic() { fn test_run_basic() {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
rx.recv().unwrap(); rx.recv().unwrap();
@ -732,7 +732,7 @@ mod test {
#[test] #[test]
fn test_join_success() { fn test_join_success() {
match Thread::scoped(move|| -> String { match thread::spawn(move|| -> String {
"Success!".to_string() "Success!".to_string()
}).join().as_ref().map(|s| &**s) { }).join().as_ref().map(|s| &**s) {
result::Result::Ok("Success!") => (), result::Result::Ok("Success!") => (),
@ -742,7 +742,7 @@ mod test {
#[test] #[test]
fn test_join_panic() { fn test_join_panic() {
match Thread::scoped(move|| { match thread::spawn(move|| {
panic!() panic!()
}).join() { }).join() {
result::Result::Err(_) => (), result::Result::Err(_) => (),
@ -750,6 +750,26 @@ mod test {
} }
} }
#[test]
fn test_scoped_success() {
let res = thread::scoped(move|| -> String {
"Success!".to_string()
}).join();
assert!(res == "Success!");
}
#[test]
#[should_fail]
fn test_scoped_panic() {
thread::scoped(|| panic!()).join();
}
#[test]
#[should_fail]
fn test_scoped_implicit_panic() {
thread::scoped(|| panic!());
}
#[test] #[test]
fn test_spawn_sched() { fn test_spawn_sched() {
use clone::Clone; use clone::Clone;
@ -758,7 +778,7 @@ mod test {
fn f(i: int, tx: Sender<()>) { fn f(i: int, tx: Sender<()>) {
let tx = tx.clone(); let tx = tx.clone();
Thread::spawn(move|| { thread::spawn(move|| {
if i == 0 { if i == 0 {
tx.send(()).unwrap(); tx.send(()).unwrap();
} else { } else {
@ -775,8 +795,8 @@ mod test {
fn test_spawn_sched_childs_on_default_sched() { fn test_spawn_sched_childs_on_default_sched() {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(()).unwrap(); tx.send(()).unwrap();
}); });
}); });
@ -802,14 +822,14 @@ mod test {
#[test] #[test]
fn test_avoid_copying_the_body_spawn() { fn test_avoid_copying_the_body_spawn() {
avoid_copying_the_body(|v| { avoid_copying_the_body(|v| {
Thread::spawn(move || v.invoke(())); thread::spawn(move || v.invoke(()));
}); });
} }
#[test] #[test]
fn test_avoid_copying_the_body_thread_spawn() { fn test_avoid_copying_the_body_thread_spawn() {
avoid_copying_the_body(|f| { avoid_copying_the_body(|f| {
Thread::spawn(move|| { thread::spawn(move|| {
f.invoke(()); f.invoke(());
}); });
}) })
@ -818,7 +838,7 @@ mod test {
#[test] #[test]
fn test_avoid_copying_the_body_join() { fn test_avoid_copying_the_body_join() {
avoid_copying_the_body(|f| { avoid_copying_the_body(|f| {
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
f.invoke(()) f.invoke(())
}).join(); }).join();
}) })
@ -834,21 +854,21 @@ mod test {
fn child_no(x: uint) -> Thunk { fn child_no(x: uint) -> Thunk {
return Thunk::new(move|| { return Thunk::new(move|| {
if x < GENERATIONS { if x < GENERATIONS {
Thread::spawn(move|| child_no(x+1).invoke(())); thread::spawn(move|| child_no(x+1).invoke(()));
} }
}); });
} }
Thread::spawn(|| child_no(0).invoke(())); thread::spawn(|| child_no(0).invoke(()));
} }
#[test] #[test]
fn test_simple_newsched_spawn() { fn test_simple_newsched_spawn() {
Thread::spawn(move || {}); thread::spawn(move || {});
} }
#[test] #[test]
fn test_try_panic_message_static_str() { fn test_try_panic_message_static_str() {
match Thread::scoped(move|| { match thread::spawn(move|| {
panic!("static string"); panic!("static string");
}).join() { }).join() {
Err(e) => { Err(e) => {
@ -862,7 +882,7 @@ mod test {
#[test] #[test]
fn test_try_panic_message_owned_str() { fn test_try_panic_message_owned_str() {
match Thread::scoped(move|| { match thread::spawn(move|| {
panic!("owned string".to_string()); panic!("owned string".to_string());
}).join() { }).join() {
Err(e) => { Err(e) => {
@ -876,7 +896,7 @@ mod test {
#[test] #[test]
fn test_try_panic_message_any() { fn test_try_panic_message_any() {
match Thread::scoped(move|| { match thread::spawn(move|| {
panic!(box 413u16 as Box<Any + Send>); panic!(box 413u16 as Box<Any + Send>);
}).join() { }).join() {
Err(e) => { Err(e) => {
@ -894,7 +914,7 @@ mod test {
fn test_try_panic_message_unit_struct() { fn test_try_panic_message_unit_struct() {
struct Juju; struct Juju;
match Thread::scoped(move|| { match thread::spawn(move|| {
panic!(Juju) panic!(Juju)
}).join() { }).join() {
Err(ref e) if e.is::<Juju>() => {} Err(ref e) if e.is::<Juju>() => {}
@ -920,15 +940,15 @@ mod test {
#[test] #[test]
fn test_park_timeout_unpark_before() { fn test_park_timeout_unpark_before() {
for _ in 0..10 { for _ in 0..10 {
Thread::current().unpark(); thread::current().unpark();
Thread::park_timeout(Duration::seconds(10_000_000)); thread::park_timeout(Duration::seconds(10_000_000));
} }
} }
#[test] #[test]
fn test_park_timeout_unpark_not_called() { fn test_park_timeout_unpark_not_called() {
for _ in 0..10 { for _ in 0..10 {
Thread::park_timeout(Duration::milliseconds(10)); thread::park_timeout(Duration::milliseconds(10));
} }
} }
@ -937,14 +957,14 @@ mod test {
use std::old_io; use std::old_io;
for _ in 0..10 { for _ in 0..10 {
let th = Thread::current(); let th = thread::current();
let _guard = Thread::scoped(move || { let _guard = thread::spawn(move || {
old_io::timer::sleep(Duration::milliseconds(50)); old_io::timer::sleep(Duration::milliseconds(50));
th.unpark(); th.unpark();
}); });
Thread::park_timeout(Duration::seconds(10_000_000)); thread::park_timeout(Duration::seconds(10_000_000));
} }
} }

18
src/libstd/thread_local/mod.rs
View file

@ -72,7 +72,7 @@ pub mod __impl {
/// ///
/// ``` /// ```
/// use std::cell::RefCell; /// use std::cell::RefCell;
/// use std::thread::Thread; /// use std::thread;
/// ///
/// thread_local!(static FOO: RefCell<uint> = RefCell::new(1)); /// thread_local!(static FOO: RefCell<uint> = RefCell::new(1));
/// ///
@ -82,7 +82,7 @@ pub mod __impl {
/// }); /// });
/// ///
/// // each thread starts out with the initial value of 1 /// // each thread starts out with the initial value of 1
/// Thread::spawn(move|| { /// thread::spawn(move|| {
/// FOO.with(|f| { /// FOO.with(|f| {
/// assert_eq!(*f.borrow(), 1); /// assert_eq!(*f.borrow(), 1);
/// *f.borrow_mut() = 3; /// *f.borrow_mut() = 3;
@ -548,7 +548,7 @@ mod tests {
use sync::mpsc::{channel, Sender}; use sync::mpsc::{channel, Sender};
use cell::UnsafeCell; use cell::UnsafeCell;
use super::State; use super::State;
use thread::Thread; use thread;
struct Foo(Sender<()>); struct Foo(Sender<()>);
@ -568,7 +568,7 @@ mod tests {
*f.get() = 2; *f.get() = 2;
}); });
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
FOO.with(|f| unsafe { FOO.with(|f| unsafe {
assert_eq!(*f.get(), 1); assert_eq!(*f.get(), 1);
}); });
@ -595,7 +595,7 @@ mod tests {
} }
thread_local!(static FOO: Foo = foo()); thread_local!(static FOO: Foo = foo());
Thread::scoped(|| { thread::spawn(|| {
assert!(FOO.state() == State::Uninitialized); assert!(FOO.state() == State::Uninitialized);
FOO.with(|_| { FOO.with(|_| {
assert!(FOO.state() == State::Valid); assert!(FOO.state() == State::Valid);
@ -611,7 +611,7 @@ mod tests {
}); });
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| unsafe { let _t = thread::spawn(move|| unsafe {
let mut tx = Some(tx); let mut tx = Some(tx);
FOO.with(|f| { FOO.with(|f| {
*f.get() = Some(Foo(tx.take().unwrap())); *f.get() = Some(Foo(tx.take().unwrap()));
@ -659,7 +659,7 @@ mod tests {
} }
} }
Thread::scoped(move|| { thread::spawn(move|| {
drop(S1); drop(S1);
}).join().ok().unwrap(); }).join().ok().unwrap();
} }
@ -677,7 +677,7 @@ mod tests {
} }
} }
Thread::scoped(move|| unsafe { thread::spawn(move|| unsafe {
K1.with(|s| *s.get() = Some(S1)); K1.with(|s| *s.get() = Some(S1));
}).join().ok().unwrap(); }).join().ok().unwrap();
} }
@ -704,7 +704,7 @@ mod tests {
} }
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| unsafe { let _t = thread::spawn(move|| unsafe {
let mut tx = Some(tx); let mut tx = Some(tx);
K1.with(|s| *s.get() = Some(S1(tx.take().unwrap()))); K1.with(|s| *s.get() = Some(S1(tx.take().unwrap())));
}); });

12
src/libstd/thread_local/scoped.rs
View file

@ -84,7 +84,7 @@ macro_rules! __scoped_thread_local_inner {
target_os = "openbsd", target_os = "openbsd",
target_arch = "aarch64")), target_arch = "aarch64")),
thread_local)] thread_local)]
static $name: ::std::thread_local::scoped::Key<$t> = static $name: ::std::thread_local::spawn::Key<$t> =
__scoped_thread_local_inner!($t); __scoped_thread_local_inner!($t);
); );
(pub static $name:ident: $t:ty) => ( (pub static $name:ident: $t:ty) => (
@ -94,11 +94,11 @@ macro_rules! __scoped_thread_local_inner {
target_os = "openbsd", target_os = "openbsd",
target_arch = "aarch64")), target_arch = "aarch64")),
thread_local)] thread_local)]
pub static $name: ::std::thread_local::scoped::Key<$t> = pub static $name: ::std::thread_local::spawn::Key<$t> =
__scoped_thread_local_inner!($t); __scoped_thread_local_inner!($t);
); );
($t:ty) => ({ ($t:ty) => ({
use std::thread_local::scoped::Key as __Key; use std::thread_local::spawn::Key as __Key;
#[cfg(not(any(windows, #[cfg(not(any(windows,
target_os = "android", target_os = "android",
@ -106,7 +106,7 @@ macro_rules! __scoped_thread_local_inner {
target_os = "openbsd", target_os = "openbsd",
target_arch = "aarch64")))] target_arch = "aarch64")))]
const _INIT: __Key<$t> = __Key { const _INIT: __Key<$t> = __Key {
inner: ::std::thread_local::scoped::__impl::KeyInner { inner: ::std::thread_local::spawn::__impl::KeyInner {
inner: ::std::cell::UnsafeCell { value: 0 as *mut _ }, inner: ::std::cell::UnsafeCell { value: 0 as *mut _ },
} }
}; };
@ -117,8 +117,8 @@ macro_rules! __scoped_thread_local_inner {
target_os = "openbsd", target_os = "openbsd",
target_arch = "aarch64"))] target_arch = "aarch64"))]
const _INIT: __Key<$t> = __Key { const _INIT: __Key<$t> = __Key {
inner: ::std::thread_local::scoped::__impl::KeyInner { inner: ::std::thread_local::spawn::__impl::KeyInner {
inner: ::std::thread_local::scoped::__impl::OS_INIT, inner: ::std::thread_local::spawn::__impl::OS_INIT,
marker: ::std::marker::InvariantType, marker: ::std::marker::InvariantType,
} }
}; };

2
src/libtest/lib.rs
View file

@ -879,7 +879,7 @@ pub fn run_test(opts: &TestOpts,
monitor_ch: Sender<MonitorMsg>, monitor_ch: Sender<MonitorMsg>,
nocapture: bool, nocapture: bool,
testfn: Thunk) { testfn: Thunk) {
Thread::spawn(move || { thread::spawn(move || {
let (tx, rx) = channel(); let (tx, rx) = channel();
let mut reader = ChanReader::new(rx); let mut reader = ChanReader::new(rx);
let stdout = ChanWriter::new(tx.clone()); let stdout = ChanWriter::new(tx.clone());

4
src/test/auxiliary/cci_capture_clause.rs
View file

@ -8,12 +8,12 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::thread::Thread; use std::thread;
use std::sync::mpsc::{Receiver, channel}; use std::sync::mpsc::{Receiver, channel};
pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> { pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> {
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(x.clone()); tx.send(x.clone());
}); });
rx rx

6
src/test/bench/msgsend-pipes-shared.rs
View file

@ -21,7 +21,7 @@
use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::mpsc::{channel, Sender, Receiver};
use std::os; use std::os;
use std::env; use std::env;
use std::thread::Thread; use std::thread;
use std::time::Duration; use std::time::Duration;
fn move_out<T>(_x: T) {} fn move_out<T>(_x: T) {}
@ -64,7 +64,7 @@ fn run(args: &[String]) {
let mut worker_results = Vec::new(); let mut worker_results = Vec::new();
for _ in 0u..workers { for _ in 0u..workers {
let to_child = to_child.clone(); let to_child = to_child.clone();
worker_results.push(Thread::scoped(move|| { worker_results.push(thread::spawn(move|| {
for _ in 0u..size / workers { for _ in 0u..size / workers {
//println!("worker {}: sending {} bytes", i, num_bytes); //println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes)).unwrap(); to_child.send(request::bytes(num_bytes)).unwrap();
@ -72,7 +72,7 @@ fn run(args: &[String]) {
//println!("worker {} exiting", i); //println!("worker {} exiting", i);
})); }));
} }
Thread::spawn(move|| { thread::spawn(move|| {
server(&from_parent, &to_parent); server(&from_parent, &to_parent);
}); });

8
src/test/bench/msgsend-pipes.rs
View file

@ -17,7 +17,7 @@
use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::mpsc::{channel, Sender, Receiver};
use std::os; use std::os;
use std::env; use std::env;
use std::thread::Thread; use std::thread;
use std::time::Duration; use std::time::Duration;
enum request { enum request {
@ -57,7 +57,7 @@ fn run(args: &[String]) {
let mut worker_results = Vec::new(); let mut worker_results = Vec::new();
let from_parent = if workers == 1 { let from_parent = if workers == 1 {
let (to_child, from_parent) = channel(); let (to_child, from_parent) = channel();
worker_results.push(Thread::scoped(move|| { worker_results.push(thread::spawn(move|| {
for _ in 0u..size / workers { for _ in 0u..size / workers {
//println!("worker {}: sending {} bytes", i, num_bytes); //println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes)); to_child.send(request::bytes(num_bytes));
@ -69,7 +69,7 @@ fn run(args: &[String]) {
let (to_child, from_parent) = channel(); let (to_child, from_parent) = channel();
for _ in 0u..workers { for _ in 0u..workers {
let to_child = to_child.clone(); let to_child = to_child.clone();
worker_results.push(Thread::scoped(move|| { worker_results.push(thread::spawn(move|| {
for _ in 0u..size / workers { for _ in 0u..size / workers {
//println!("worker {}: sending {} bytes", i, num_bytes); //println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes)); to_child.send(request::bytes(num_bytes));
@ -79,7 +79,7 @@ fn run(args: &[String]) {
} }
from_parent from_parent
}; };
Thread::spawn(move|| { thread::spawn(move|| {
server(&from_parent, &to_parent); server(&from_parent, &to_parent);
}); });

6
src/test/bench/rt-messaging-ping-pong.rs
View file

@ -19,7 +19,7 @@
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use std::os; use std::os;
use std::thread::Thread; use std::thread;
// This is a simple bench that creates M pairs of tasks. These // This is a simple bench that creates M pairs of tasks. These
// tasks ping-pong back and forth over a pair of streams. This is a // tasks ping-pong back and forth over a pair of streams. This is a
@ -35,7 +35,7 @@ fn ping_pong_bench(n: uint, m: uint) {
// Create a channel: B->A // Create a channel: B->A
let (btx, brx) = channel(); let (btx, brx) = channel();
let guard_a = Thread::scoped(move|| { let guard_a = thread::spawn(move|| {
let (tx, rx) = (atx, brx); let (tx, rx) = (atx, brx);
for _ in 0..n { for _ in 0..n {
tx.send(()).unwrap(); tx.send(()).unwrap();
@ -43,7 +43,7 @@ fn ping_pong_bench(n: uint, m: uint) {
} }
}); });
let guard_b = Thread::scoped(move|| { let guard_b = thread::spawn(move|| {
let (tx, rx) = (btx, arx); let (tx, rx) = (btx, arx);
for _ in 0..n { for _ in 0..n {
rx.recv().unwrap(); rx.recv().unwrap();

4
src/test/bench/rt-parfib.rs
View file

@ -10,7 +10,7 @@
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use std::os; use std::os;
use std::thread::Thread; use std::thread;
// A simple implementation of parfib. One subtree is found in a new // A simple implementation of parfib. One subtree is found in a new
// task and communicated over a oneshot pipe, the other is found // task and communicated over a oneshot pipe, the other is found
@ -22,7 +22,7 @@ fn parfib(n: uint) -> uint {
} }
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
tx.send(parfib(n-1)).unwrap(); tx.send(parfib(n-1)).unwrap();
}); });
let m2 = parfib(n-2); let m2 = parfib(n-2);

2
src/test/bench/shootout-binarytrees.rs
View file

@ -111,7 +111,7 @@ fn main() {
let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| { let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
use std::num::Int; use std::num::Int;
let iterations = 2.pow((max_depth - depth + min_depth) as usize); let iterations = 2.pow((max_depth - depth + min_depth) as usize);
Thread::scoped(move || inner(depth, iterations)) thread::spawn(move || inner(depth, iterations))
}).collect::<Vec<_>>(); }).collect::<Vec<_>>();
for message in messages { for message in messages {

4
src/test/bench/shootout-chameneos-redux.rs
View file

@ -43,7 +43,7 @@
use self::Color::{Red, Yellow, Blue}; use self::Color::{Red, Yellow, Blue};
use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::mpsc::{channel, Sender, Receiver};
use std::fmt; use std::fmt;
use std::thread::Thread; use std::thread;
fn print_complements() { fn print_complements() {
let all = [Blue, Red, Yellow]; let all = [Blue, Red, Yellow];
@ -187,7 +187,7 @@ fn rendezvous(nn: uint, set: Vec<Color>) {
let to_rendezvous = to_rendezvous.clone(); let to_rendezvous = to_rendezvous.clone();
let to_rendezvous_log = to_rendezvous_log.clone(); let to_rendezvous_log = to_rendezvous_log.clone();
let (to_creature, from_rendezvous) = channel(); let (to_creature, from_rendezvous) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
creature(ii, creature(ii,
col, col,
from_rendezvous, from_rendezvous,

4
src/test/bench/shootout-fannkuch-redux.rs
View file

@ -39,7 +39,7 @@
// OF THE POSSIBILITY OF SUCH DAMAGE. // OF THE POSSIBILITY OF SUCH DAMAGE.
use std::{cmp, iter, mem}; use std::{cmp, iter, mem};
use std::thread::Thread; use std::thread;
fn rotate(x: &mut [i32]) { fn rotate(x: &mut [i32]) {
let mut prev = x[0]; let mut prev = x[0];
@ -164,7 +164,7 @@ fn fannkuch(n: i32) -> (i32, i32) {
for (_, j) in (0..N).zip(iter::count(0, k)) { for (_, j) in (0..N).zip(iter::count(0, k)) {
let max = cmp::min(j+k, perm.max()); let max = cmp::min(j+k, perm.max());
futures.push(Thread::scoped(move|| { futures.push(thread::spawn(move|| {
work(perm, j as uint, max as uint) work(perm, j as uint, max as uint)
})) }))
} }

4
src/test/bench/shootout-k-nucleotide-pipes.rs
View file

@ -24,7 +24,7 @@ use std::option;
use std::os; use std::os;
use std::env; use std::env;
use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread::Thread; use std::thread;
fn f64_cmp(x: f64, y: f64) -> Ordering { fn f64_cmp(x: f64, y: f64) -> Ordering {
// arbitrarily decide that NaNs are larger than everything. // arbitrarily decide that NaNs are larger than everything.
@ -172,7 +172,7 @@ fn main() {
let (to_child, from_parent) = channel(); let (to_child, from_parent) = channel();
Thread::spawn(move|| { thread::spawn(move|| {
make_sequence_processor(sz, &from_parent, &to_parent_); make_sequence_processor(sz, &from_parent, &to_parent_);
}); });

6
src/test/bench/shootout-k-nucleotide.rs
View file

@ -45,7 +45,7 @@
use std::ascii::OwnedAsciiExt; use std::ascii::OwnedAsciiExt;
use std::slice; use std::slice;
use std::sync::Arc; use std::sync::Arc;
use std::thread::Thread; use std::thread;
static TABLE: [u8;4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ]; static TABLE: [u8;4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ];
static TABLE_SIZE: uint = 2 << 16; static TABLE_SIZE: uint = 2 << 16;
@ -303,11 +303,11 @@ fn main() {
let nb_freqs: Vec<_> = (1u..3).map(|i| { let nb_freqs: Vec<_> = (1u..3).map(|i| {
let input = input.clone(); let input = input.clone();
(i, Thread::scoped(move|| generate_frequencies(&input, i))) (i, thread::spawn(move|| generate_frequencies(&input, i)))
}).collect(); }).collect();
let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| { let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| {
let input = input.clone(); let input = input.clone();
Thread::scoped(move|| generate_frequencies(&input, occ.len())) thread::spawn(move|| generate_frequencies(&input, occ.len()))
}).collect(); }).collect();
for (i, freq) in nb_freqs { for (i, freq) in nb_freqs {

6
src/test/bench/shootout-mandelbrot.rs
View file

@ -46,7 +46,7 @@ use std::old_io;
use std::os; use std::os;
use std::simd::f64x2; use std::simd::f64x2;
use std::sync::Arc; use std::sync::Arc;
use std::thread::Thread; use std::thread;
const ITER: usize = 50; const ITER: usize = 50;
const LIMIT: f64 = 2.0; const LIMIT: f64 = 2.0;
@ -81,7 +81,7 @@ fn mandelbrot<W: old_io::Writer>(w: usize, mut out: W) -> old_io::IoResult<()> {
let mut precalc_i = Vec::with_capacity(h); let mut precalc_i = Vec::with_capacity(h);
let precalc_futures = (0..WORKERS).map(|i| { let precalc_futures = (0..WORKERS).map(|i| {
Thread::scoped(move|| { thread::spawn(move|| {
let mut rs = Vec::with_capacity(w / WORKERS); let mut rs = Vec::with_capacity(w / WORKERS);
let mut is = Vec::with_capacity(w / WORKERS); let mut is = Vec::with_capacity(w / WORKERS);
@ -122,7 +122,7 @@ fn mandelbrot<W: old_io::Writer>(w: usize, mut out: W) -> old_io::IoResult<()> {
let vec_init_r = arc_init_r.clone(); let vec_init_r = arc_init_r.clone();
let vec_init_i = arc_init_i.clone(); let vec_init_i = arc_init_i.clone();
Thread::scoped(move|| { thread::spawn(move|| {
let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8); let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8);
let init_r_slice = vec_init_r; let init_r_slice = vec_init_r;

4
src/test/bench/shootout-meteor.rs
View file

@ -43,7 +43,7 @@
use std::iter::repeat; use std::iter::repeat;
use std::sync::Arc; use std::sync::Arc;
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use std::thread::Thread; use std::thread;
// //
// Utilities. // Utilities.
@ -317,7 +317,7 @@ fn par_search(masks: Vec<Vec<Vec<u64>>>) -> Data {
let masks = masks.clone(); let masks = masks.clone();
let tx = tx.clone(); let tx = tx.clone();
let m = *m; let m = *m;
Thread::spawn(move|| { thread::spawn(move|| {
let mut data = Data::new(); let mut data = Data::new();
search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data); search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data);
tx.send(data).unwrap(); tx.send(data).unwrap();

10
src/test/bench/shootout-pfib.rs
View file

@ -24,7 +24,7 @@ use std::sync::mpsc::{channel, Sender};
use std::os; use std::os;
use std::env; use std::env;
use std::result::Result::{Ok, Err}; use std::result::Result::{Ok, Err};
use std::thread::Thread; use std::thread;
use std::time::Duration; use std::time::Duration;
fn fib(n: int) -> int { fn fib(n: int) -> int {
@ -36,15 +36,15 @@ fn fib(n: int) -> int {
} else { } else {
let (tx1, rx) = channel(); let (tx1, rx) = channel();
let tx2 = tx1.clone(); let tx2 = tx1.clone();
Thread::spawn(move|| pfib(&tx2, n - 1)); thread::spawn(move|| pfib(&tx2, n - 1));
let tx2 = tx1.clone(); let tx2 = tx1.clone();
Thread::spawn(move|| pfib(&tx2, n - 2)); thread::spawn(move|| pfib(&tx2, n - 2));
tx.send(rx.recv().unwrap() + rx.recv().unwrap()); tx.send(rx.recv().unwrap() + rx.recv().unwrap());
} }
} }
let (tx, rx) = channel(); let (tx, rx) = channel();
Thread::spawn(move|| pfib(&tx, n) ); thread::spawn(move|| pfib(&tx, n) );
rx.recv().unwrap() rx.recv().unwrap()
} }
@ -79,7 +79,7 @@ fn stress_task(id: int) {
fn stress(num_tasks: int) { fn stress(num_tasks: int) {
let mut results = Vec::new(); let mut results = Vec::new();
for i in 0..num_tasks { for i in 0..num_tasks {
results.push(Thread::scoped(move|| { results.push(thread::spawn(move|| {
stress_task(i); stress_task(i);
})); }));
} }

4
src/test/bench/shootout-reverse-complement.rs
View file

@ -47,7 +47,7 @@ extern crate libc;
use std::old_io::stdio::{stdin_raw, stdout_raw}; use std::old_io::stdio::{stdin_raw, stdout_raw};
use std::old_io::{IoResult, EndOfFile}; use std::old_io::{IoResult, EndOfFile};
use std::ptr::{copy_memory, Unique}; use std::ptr::{copy_memory, Unique};
use std::thread::Thread; use std::thread;
struct Tables { struct Tables {
table8: [u8;1 << 8], table8: [u8;1 << 8],
@ -241,7 +241,7 @@ fn parallel<'a, I, T, F>(iter: I, f: F)
// boundary. // boundary.
let f = Racy(&f as *const F as *const uint); let f = Racy(&f as *const F as *const uint);
let raw = Racy(chunk.repr()); let raw = Racy(chunk.repr());
Thread::scoped(move|| { thread::spawn(move|| {
let f = f.0 as *const F; let f = f.0 as *const F;
unsafe { (*f)(mem::transmute(raw.0)) } unsafe { (*f)(mem::transmute(raw.0)) }
}) })

4
src/test/bench/shootout-spectralnorm.rs
View file

@ -44,7 +44,7 @@
#![feature(unboxed_closures)] #![feature(unboxed_closures)]
use std::iter::{repeat, AdditiveIterator}; use std::iter::{repeat, AdditiveIterator};
use std::thread::Thread; use std::thread;
use std::mem; use std::mem;
use std::num::Float; use std::num::Float;
use std::os; use std::os;
@ -129,7 +129,7 @@ fn parallel<T, F>(v: &mut [T], f: F)
// boundary. // boundary.
let f = Racy(&f as *const _ as *const uint); let f = Racy(&f as *const _ as *const uint);
let raw = Racy(chunk.repr()); let raw = Racy(chunk.repr());
Thread::scoped(move|| { thread::spawn(move|| {
let f = f.0 as *const F; let f = f.0 as *const F;
unsafe { (*f)(i * size, mem::transmute(raw.0)) } unsafe { (*f)(i * size, mem::transmute(raw.0)) }
}) })

6
src/test/bench/shootout-threadring.rs
View file

@ -39,7 +39,7 @@
// OF THE POSSIBILITY OF SUCH DAMAGE. // OF THE POSSIBILITY OF SUCH DAMAGE.
use std::sync::mpsc::{channel, Sender, Receiver}; use std::sync::mpsc::{channel, Sender, Receiver};
use std::thread::Thread; use std::thread;
fn start(n_tasks: i32, token: i32) { fn start(n_tasks: i32, token: i32) {
let (tx, mut rx) = channel(); let (tx, mut rx) = channel();
@ -48,9 +48,9 @@ fn start(n_tasks: i32, token: i32) {
for i in 2 .. n_tasks + 1 { for i in 2 .. n_tasks + 1 {
let (tx, next_rx) = channel(); let (tx, next_rx) = channel();
let cur_rx = std::mem::replace(&mut rx, next_rx); let cur_rx = std::mem::replace(&mut rx, next_rx);
guards.push(Thread::scoped(move|| roundtrip(i, tx, cur_rx))); guards.push(thread::spawn(move|| roundtrip(i, tx, cur_rx)));
} }
let guard = Thread::scoped(move|| roundtrip(1, tx, rx)); let guard = thread::spawn(move|| roundtrip(1, tx, rx));
} }
fn roundtrip(id: i32, tx: Sender<i32>, rx: Receiver<i32>) { fn roundtrip(id: i32, tx: Sender<i32>, rx: Receiver<i32>) {

4
src/test/bench/task-perf-alloc-unwind.rs
View file

@ -11,7 +11,7 @@
#![feature(unsafe_destructor, box_syntax)] #![feature(unsafe_destructor, box_syntax)]
use std::env; use std::env;
use std::thread::Thread; use std::thread;
use std::time::Duration; use std::time::Duration;
#[derive(Clone)] #[derive(Clone)]
@ -32,7 +32,7 @@ fn main() {
fn run(repeat: int, depth: int) { fn run(repeat: int, depth: int) {
for _ in 0..repeat { for _ in 0..repeat {
let dur = Duration::span(|| { let dur = Duration::span(|| {
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
recurse_or_panic(depth, None) recurse_or_panic(depth, None)
}).join(); }).join();
}); });

6
src/test/bench/task-perf-jargon-metal-smoke.rs
View file

@ -20,15 +20,15 @@
use std::sync::mpsc::{channel, Sender}; use std::sync::mpsc::{channel, Sender};
use std::os; use std::os;
use std::env; use std::env;
use std::thread::Thread; use std::thread;
fn child_generation(gens_left: uint, tx: Sender<()>) { fn child_generation(gens_left: uint, tx: Sender<()>) {
// This used to be O(n^2) in the number of generations that ever existed. // This used to be O(n^2) in the number of generations that ever existed.
// With this code, only as many generations are alive at a time as tasks // With this code, only as many generations are alive at a time as tasks
// alive at a time, // alive at a time,
Thread::spawn(move|| { thread::spawn(move|| {
if gens_left & 1 == 1 { if gens_left & 1 == 1 {
Thread::yield_now(); // shake things up a bit thread::yield_now(); // shake things up a bit
} }
if gens_left > 0 { if gens_left > 0 {
child_generation(gens_left - 1, tx); // recurse child_generation(gens_left - 1, tx); // recurse

6
src/test/bench/task-perf-spawnalot.rs
View file

@ -10,12 +10,12 @@
use std::os; use std::os;
use std::env; use std::env;
use std::thread::Thread; use std::thread;
fn f(n: uint) { fn f(n: uint) {
let mut i = 0u; let mut i = 0u;
while i < n { while i < n {
let _ = Thread::scoped(move|| g()).join(); let _ = thread::spawn(move|| g()).join();
i += 1u; i += 1u;
} }
} }
@ -33,5 +33,5 @@ fn main() {
}; };
let n = args[1].parse().unwrap(); let n = args[1].parse().unwrap();
let mut i = 0u; let mut i = 0u;
while i < n { Thread::spawn(move|| f(n) ); i += 1u; } while i < n { thread::spawn(move|| f(n) ); i += 1u; }
} }

6
src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
View file

@ -10,7 +10,7 @@
#![feature(box_syntax)] #![feature(box_syntax)]
use std::thread::Thread; use std::thread;
fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) { fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
f(v); f(v);
@ -19,7 +19,7 @@ fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
fn box_imm() { fn box_imm() {
let v = box 3; let v = box 3;
let _w = &v; let _w = &v;
Thread::spawn(move|| { thread::spawn(move|| {
println!("v={}", *v); println!("v={}", *v);
//~^ ERROR cannot move `v` into closure //~^ ERROR cannot move `v` into closure
}); });
@ -28,7 +28,7 @@ fn box_imm() {
fn box_imm_explicit() { fn box_imm_explicit() {
let v = box 3; let v = box 3;
let _w = &v; let _w = &v;
Thread::spawn(move|| { thread::spawn(move|| {
println!("v={}", *v); println!("v={}", *v);
//~^ ERROR cannot move //~^ ERROR cannot move
}); });

10
src/test/compile-fail/borrowck-multiple-captures.rs
View file

@ -10,7 +10,7 @@
#![feature(box_syntax)] #![feature(box_syntax)]
use std::thread::Thread; use std::thread;
fn borrow<T>(_: &T) { } fn borrow<T>(_: &T) { }
@ -19,7 +19,7 @@ fn different_vars_after_borrows() {
let p1 = &x1; let p1 = &x1;
let x2 = box 2; let x2 = box 2;
let p2 = &x2; let p2 = &x2;
Thread::spawn(move|| { thread::spawn(move|| {
drop(x1); //~ ERROR cannot move `x1` into closure because it is borrowed drop(x1); //~ ERROR cannot move `x1` into closure because it is borrowed
drop(x2); //~ ERROR cannot move `x2` into closure because it is borrowed drop(x2); //~ ERROR cannot move `x2` into closure because it is borrowed
}); });
@ -32,7 +32,7 @@ fn different_vars_after_moves() {
drop(x1); drop(x1);
let x2 = box 2; let x2 = box 2;
drop(x2); drop(x2);
Thread::spawn(move|| { thread::spawn(move|| {
drop(x1); //~ ERROR capture of moved value: `x1` drop(x1); //~ ERROR capture of moved value: `x1`
drop(x2); //~ ERROR capture of moved value: `x2` drop(x2); //~ ERROR capture of moved value: `x2`
}); });
@ -41,7 +41,7 @@ fn different_vars_after_moves() {
fn same_var_after_borrow() { fn same_var_after_borrow() {
let x = box 1; let x = box 1;
let p = &x; let p = &x;
Thread::spawn(move|| { thread::spawn(move|| {
drop(x); //~ ERROR cannot move `x` into closure because it is borrowed drop(x); //~ ERROR cannot move `x` into closure because it is borrowed
drop(x); //~ ERROR use of moved value: `x` drop(x); //~ ERROR use of moved value: `x`
}); });
@ -51,7 +51,7 @@ fn same_var_after_borrow() {
fn same_var_after_move() { fn same_var_after_move() {
let x = box 1; let x = box 1;
drop(x); drop(x);
Thread::spawn(move|| { thread::spawn(move|| {
drop(x); //~ ERROR capture of moved value: `x` drop(x); //~ ERROR capture of moved value: `x`
drop(x); //~ ERROR use of moved value: `x` drop(x); //~ ERROR use of moved value: `x`
}); });

4
src/test/compile-fail/issue-12041.rs
View file

@ -9,11 +9,11 @@
// except according to those terms. // except according to those terms.
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::spawn(move|| -> () { let _t = thread::spawn(move|| -> () {
loop { loop {
let tx = tx; let tx = tx;
//~^ ERROR: use of moved value: `tx` //~^ ERROR: use of moved value: `tx`

42
src/test/compile-fail/issue-8460-const.rs
View file

@ -9,47 +9,47 @@
// except according to those terms. // except according to those terms.
use std::{int, i8, i16, i32, i64}; use std::{int, i8, i16, i32, i64};
use std::thread::Thread; use std::thread;
fn main() { fn main() {
assert!(Thread::scoped(move|| int::MIN / -1).join().is_err()); assert!(thread::spawn(move|| int::MIN / -1).join().is_err());
//~^ ERROR attempted to divide with overflow in a constant expression //~^ ERROR attempted to divide with overflow in a constant expression
assert!(Thread::scoped(move|| i8::MIN / -1).join().is_err()); assert!(thread::spawn(move|| i8::MIN / -1).join().is_err());
//~^ ERROR attempted to divide with overflow in a constant expression //~^ ERROR attempted to divide with overflow in a constant expression
assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err()); assert!(thread::spawn(move|| i16::MIN / -1).join().is_err());
//~^ ERROR attempted to divide with overflow in a constant expression //~^ ERROR attempted to divide with overflow in a constant expression
assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err()); assert!(thread::spawn(move|| i32::MIN / -1).join().is_err());
//~^ ERROR attempted to divide with overflow in a constant expression //~^ ERROR attempted to divide with overflow in a constant expression
assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err()); assert!(thread::spawn(move|| i64::MIN / -1).join().is_err());
//~^ ERROR attempted to divide with overflow in a constant expression //~^ ERROR attempted to divide with overflow in a constant expression
assert!(Thread::scoped(move|| 1is / 0).join().is_err()); assert!(thread::spawn(move|| 1is / 0).join().is_err());
//~^ ERROR attempted to divide by zero in a constant expression //~^ ERROR attempted to divide by zero in a constant expression
assert!(Thread::scoped(move|| 1i8 / 0).join().is_err()); assert!(thread::spawn(move|| 1i8 / 0).join().is_err());
//~^ ERROR attempted to divide by zero in a constant expression //~^ ERROR attempted to divide by zero in a constant expression
assert!(Thread::scoped(move|| 1i16 / 0).join().is_err()); assert!(thread::spawn(move|| 1i16 / 0).join().is_err());
//~^ ERROR attempted to divide by zero in a constant expression //~^ ERROR attempted to divide by zero in a constant expression
assert!(Thread::scoped(move|| 1i32 / 0).join().is_err()); assert!(thread::spawn(move|| 1i32 / 0).join().is_err());
//~^ ERROR attempted to divide by zero in a constant expression //~^ ERROR attempted to divide by zero in a constant expression
assert!(Thread::scoped(move|| 1i64 / 0).join().is_err()); assert!(thread::spawn(move|| 1i64 / 0).join().is_err());
//~^ ERROR attempted to divide by zero in a constant expression //~^ ERROR attempted to divide by zero in a constant expression
assert!(Thread::scoped(move|| int::MIN % -1).join().is_err()); assert!(thread::spawn(move|| int::MIN % -1).join().is_err());
//~^ ERROR attempted remainder with overflow in a constant expression //~^ ERROR attempted remainder with overflow in a constant expression
assert!(Thread::scoped(move|| i8::MIN % -1).join().is_err()); assert!(thread::spawn(move|| i8::MIN % -1).join().is_err());
//~^ ERROR attempted remainder with overflow in a constant expression //~^ ERROR attempted remainder with overflow in a constant expression
assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err()); assert!(thread::spawn(move|| i16::MIN % -1).join().is_err());
//~^ ERROR attempted remainder with overflow in a constant expression //~^ ERROR attempted remainder with overflow in a constant expression
assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err()); assert!(thread::spawn(move|| i32::MIN % -1).join().is_err());
//~^ ERROR attempted remainder with overflow in a constant expression //~^ ERROR attempted remainder with overflow in a constant expression
assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err()); assert!(thread::spawn(move|| i64::MIN % -1).join().is_err());
//~^ ERROR attempted remainder with overflow in a constant expression //~^ ERROR attempted remainder with overflow in a constant expression
assert!(Thread::scoped(move|| 1is % 0).join().is_err()); assert!(thread::spawn(move|| 1is % 0).join().is_err());
//~^ ERROR attempted remainder with a divisor of zero in a constant expression //~^ ERROR attempted remainder with a divisor of zero in a constant expression
assert!(Thread::scoped(move|| 1i8 % 0).join().is_err()); assert!(thread::spawn(move|| 1i8 % 0).join().is_err());
//~^ ERROR attempted remainder with a divisor of zero in a constant expression //~^ ERROR attempted remainder with a divisor of zero in a constant expression
assert!(Thread::scoped(move|| 1i16 % 0).join().is_err()); assert!(thread::spawn(move|| 1i16 % 0).join().is_err());
//~^ ERROR attempted remainder with a divisor of zero in a constant expression //~^ ERROR attempted remainder with a divisor of zero in a constant expression
assert!(Thread::scoped(move|| 1i32 % 0).join().is_err()); assert!(thread::spawn(move|| 1i32 % 0).join().is_err());
//~^ ERROR attempted remainder with a divisor of zero in a constant expression //~^ ERROR attempted remainder with a divisor of zero in a constant expression
assert!(Thread::scoped(move|| 1i64 % 0).join().is_err()); assert!(thread::spawn(move|| 1i64 % 0).join().is_err());
//~^ ERROR attempted remainder with a divisor of zero in a constant expression //~^ ERROR attempted remainder with a divisor of zero in a constant expression
} }

2
src/test/compile-fail/missing-stability.rs
View file

@ -30,4 +30,4 @@ pub mod bar {
// #[stable] is not inherited // #[stable] is not inherited
pub fn unmarked() {} pub fn unmarked() {}
//~^ ERROR This node does not have a stability attribute //~^ ERROR This node does not have a stability attribute
} }

4
src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs
View file

@ -8,11 +8,11 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let x = "Hello world!".to_string(); let x = "Hello world!".to_string();
Thread::spawn(move|| { thread::spawn(move|| {
println!("{}", x); println!("{}", x);
}); });
println!("{}", x); //~ ERROR use of moved value println!("{}", x); //~ ERROR use of moved value

4
src/test/compile-fail/no-capture-arc.rs
View file

@ -11,13 +11,13 @@
// error-pattern: use of moved value // error-pattern: use of moved value
use std::sync::Arc; use std::sync::Arc;
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
let arc_v = Arc::new(v); let arc_v = Arc::new(v);
Thread::spawn(move|| { thread::spawn(move|| {
assert_eq!((*arc_v)[3], 4); assert_eq!((*arc_v)[3], 4);
}); });

4
src/test/compile-fail/no-reuse-move-arc.rs
View file

@ -9,13 +9,13 @@
// except according to those terms. // except according to those terms.
use std::sync::Arc; use std::sync::Arc;
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
let arc_v = Arc::new(v); let arc_v = Arc::new(v);
Thread::spawn(move|| { thread::spawn(move|| {
assert_eq!((*arc_v)[3], 4); assert_eq!((*arc_v)[3], 4);
}); });

4
src/test/compile-fail/no-send-res-ports.rs
View file

@ -10,7 +10,7 @@
#![feature(unsafe_destructor)] #![feature(unsafe_destructor)]
use std::thread::Thread; use std::thread;
use std::rc::Rc; use std::rc::Rc;
#[derive(Debug)] #[derive(Debug)]
@ -35,7 +35,7 @@ fn main() {
let x = foo(Port(Rc::new(()))); let x = foo(Port(Rc::new(())));
Thread::spawn(move|| { thread::spawn(move|| {
//~^ ERROR `core::marker::Send` is not implemented //~^ ERROR `core::marker::Send` is not implemented
let y = x; let y = x;
println!("{:?}", y); println!("{:?}", y);

4
src/test/run-fail/panic-task-name-none.rs
View file

@ -10,10 +10,10 @@
// error-pattern:thread '<unnamed>' panicked at 'test' // error-pattern:thread '<unnamed>' panicked at 'test'
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let r: Result<int,_> = Thread::scoped(move|| { let r: Result<int,_> = thread::spawn(move|| {
panic!("test"); panic!("test");
1 1
}).join(); }).join();

4
src/test/run-fail/rt-set-exit-status-panic2.rs
View file

@ -12,7 +12,7 @@
#[macro_use] extern crate log; #[macro_use] extern crate log;
use std::os; use std::os;
use std::thread::Thread; use std::thread;
struct r { struct r {
x:int, x:int,
@ -35,7 +35,7 @@ fn r(x:int) -> r {
fn main() { fn main() {
error!("whatever"); error!("whatever");
let _t = Thread::spawn(move|| { let _t = thread::spawn(move|| {
let _i = r(5); let _i = r(5);
}); });
panic!(); panic!();

4
src/test/run-fail/task-spawn-barefn.rs
View file

@ -10,12 +10,12 @@
// error-pattern:Ensure that the child task runs by panicking // error-pattern:Ensure that the child task runs by panicking
use std::thread::Thread; use std::thread;
fn main() { fn main() {
// the purpose of this test is to make sure that task::spawn() // the purpose of this test is to make sure that task::spawn()
// works when provided with a bare function: // works when provided with a bare function:
let r = Thread::scoped(startfn).join(); let r = thread::spawn(startfn).join();
if r.is_err() { if r.is_err() {
panic!() panic!()
} }

4
src/test/run-pass/unique-send-2.rs
View file

@ -12,7 +12,7 @@
#![feature(box_syntax)] #![feature(box_syntax)]
use std::sync::mpsc::{channel, Sender}; use std::sync::mpsc::{channel, Sender};
use std::thread::Thread; use std::thread;
fn child(tx: &Sender<Box<uint>>, i: uint) { fn child(tx: &Sender<Box<uint>>, i: uint) {
tx.send(box i).unwrap(); tx.send(box i).unwrap();
@ -25,7 +25,7 @@ pub fn main() {
let _t = (0u..n).map(|i| { let _t = (0u..n).map(|i| {
expected += i; expected += i;
let tx = tx.clone(); let tx = tx.clone();
Thread::scoped(move|| { thread::spawn(move|| {
child(&tx, i) child(&tx, i)
}) })
}).collect::<Vec<_>>(); }).collect::<Vec<_>>();

4
src/test/run-pass/unit-like-struct-drop-run.rs
View file

@ -11,7 +11,7 @@
// Make sure the destructor is run for unit-like structs. // Make sure the destructor is run for unit-like structs.
use std::boxed::BoxAny; use std::boxed::BoxAny;
use std::thread::Thread; use std::thread;
struct Foo; struct Foo;
@ -22,7 +22,7 @@ impl Drop for Foo {
} }
pub fn main() { pub fn main() {
let x = Thread::scoped(move|| { let x = thread::spawn(move|| {
let _b = Foo; let _b = Foo;
}).join(); }).join();

4
src/test/run-pass/unwind-resource.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
use std::sync::mpsc::{channel, Sender}; use std::sync::mpsc::{channel, Sender};
use std::thread::Thread; use std::thread;
struct complainer { struct complainer {
tx: Sender<bool>, tx: Sender<bool>,
@ -37,7 +37,7 @@ fn f(tx: Sender<bool>) {
pub fn main() { pub fn main() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let _t = Thread::scoped(move|| f(tx.clone())); let _t = thread::spawn(move|| f(tx.clone()));
println!("hiiiiiiiii"); println!("hiiiiiiiii");
assert!(rx.recv().unwrap()); assert!(rx.recv().unwrap());
} }

4
src/test/run-pass/unwind-unique.rs
View file

@ -11,7 +11,7 @@
#![allow(unknown_features)] #![allow(unknown_features)]
#![feature(box_syntax)] #![feature(box_syntax)]
use std::thread::Thread; use std::thread;
fn f() { fn f() {
let _a = box 0; let _a = box 0;
@ -19,5 +19,5 @@ fn f() {
} }
pub fn main() { pub fn main() {
let _t = Thread::scoped(f); let _t = thread::spawn(f);
} }

4
src/test/run-pass/vector-sort-panic-safe.rs
View file

@ -10,7 +10,7 @@
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
use std::rand::{thread_rng, Rng, Rand}; use std::rand::{thread_rng, Rng, Rand};
use std::thread::Thread; use std::thread;
const REPEATS: usize = 5; const REPEATS: usize = 5;
const MAX_LEN: usize = 32; const MAX_LEN: usize = 32;
@ -79,7 +79,7 @@ pub fn main() {
let v = main.clone(); let v = main.clone();
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
let mut v = v; let mut v = v;
let mut panic_countdown = panic_countdown; let mut panic_countdown = panic_countdown;
v.sort_by(|a, b| { v.sort_by(|a, b| {

4
src/test/run-pass/weak-lang-item.rs
View file

@ -12,10 +12,10 @@
extern crate "weak-lang-items" as other; extern crate "weak-lang-items" as other;
use std::thread::Thread; use std::thread;
fn main() { fn main() {
let _ = Thread::scoped(move|| { let _ = thread::spawn(move|| {
other::foo() other::foo()
}); });
} }

10
src/test/run-pass/yield.rs
View file

@ -8,18 +8,18 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::thread::Thread; use std::thread;
pub fn main() { pub fn main() {
let mut result = Thread::scoped(child); let mut result = thread::spawn(child);
println!("1"); println!("1");
Thread::yield_now(); thread::yield_now();
println!("2"); println!("2");
Thread::yield_now(); thread::yield_now();
println!("3"); println!("3");
result.join(); result.join();
} }
fn child() { fn child() {
println!("4"); Thread::yield_now(); println!("5"); Thread::yield_now(); println!("6"); println!("4"); thread::yield_now(); println!("5"); thread::yield_now(); println!("6");
} }

6
src/test/run-pass/yield1.rs
View file

@ -8,12 +8,12 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::thread::Thread; use std::thread;
pub fn main() { pub fn main() {
let mut result = Thread::scoped(child); let mut result = thread::spawn(child);
println!("1"); println!("1");
Thread::yield_now(); thread::yield_now();
result.join(); result.join();
} }

4
src/test/run-pass/yield2.rs
View file

@ -8,9 +8,9 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
use std::thread::Thread; use std::thread;
pub fn main() { pub fn main() {
let mut i: int = 0; let mut i: int = 0;
while i < 100 { i = i + 1; println!("{}", i); Thread::yield_now(); } while i < 100 { i = i + 1; println!("{}", i); thread::yield_now(); }
} }