rollup merge of #22435: aturon/final-stab-thread
Conflicts: src/test/bench/rt-messaging-ping-pong.rs src/test/bench/rt-parfib.rs src/test/bench/task-perf-spawnalot.rs
This commit is contained in:
Alex Crichton
commit
d8450d69bb
@ -35,7 +35,7 @@ use std::env;
|
||||
use std::iter::repeat;
|
||||
use std::str;
|
||||
use std::string::String;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
use test::MetricMap;
|
||||
|
||||
@ -447,7 +447,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
|
||||
loop {
|
||||
//waiting 1 second for gdbserver start
|
||||
timer::sleep(Duration::milliseconds(1000));
|
||||
let result = Thread::scoped(move || {
|
||||
let result = thread::spawn(move || {
|
||||
tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
|
||||
}).join();
|
||||
if result.is_err() {
|
||||
|
||||
@ -35,14 +35,14 @@
|
||||
//!
|
||||
//! ```
|
||||
//! use std::sync::Arc;
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! let five = Arc::new(5);
|
||||
//!
|
||||
//! for _ in 0..10 {
|
||||
//! let five = five.clone();
|
||||
//!
|
||||
//! Thread::spawn(move || {
|
||||
//! thread::spawn(move || {
|
||||
//! println!("{:?}", five);
|
||||
//! });
|
||||
//! }
|
||||
@ -52,14 +52,14 @@
|
||||
//!
|
||||
//! ```
|
||||
//! use std::sync::{Arc, Mutex};
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! let five = Arc::new(Mutex::new(5));
|
||||
//!
|
||||
//! for _ in 0..10 {
|
||||
//! let five = five.clone();
|
||||
//!
|
||||
//! Thread::spawn(move || {
|
||||
//! thread::spawn(move || {
|
||||
//! let mut number = five.lock().unwrap();
|
||||
//!
|
||||
//! *number += 1;
|
||||
@ -95,7 +95,7 @@ use heap::deallocate;
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::sync::Arc;
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// fn main() {
|
||||
/// let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
|
||||
@ -104,7 +104,7 @@ use heap::deallocate;
|
||||
/// for _ in 0..10 {
|
||||
/// let child_numbers = shared_numbers.clone();
|
||||
///
|
||||
/// Thread::spawn(move || {
|
||||
/// thread::spawn(move || {
|
||||
/// let local_numbers = child_numbers.as_slice();
|
||||
///
|
||||
/// // Work with the local numbers
|
||||
@ -621,7 +621,7 @@ mod tests {
|
||||
use std::option::Option::{Some, None};
|
||||
use std::sync::atomic;
|
||||
use std::sync::atomic::Ordering::{Acquire, SeqCst};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::vec::Vec;
|
||||
use super::{Arc, Weak, weak_count, strong_count};
|
||||
use std::sync::Mutex;
|
||||
@ -648,7 +648,7 @@ mod tests {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move || {
|
||||
let _t = thread::spawn(move || {
|
||||
let arc_v: Arc<Vec<i32>> = rx.recv().unwrap();
|
||||
assert_eq!((*arc_v)[3], 4);
|
||||
});
|
||||
|
||||
@ -973,7 +973,7 @@ mod tests {
|
||||
use prelude::*;
|
||||
use std::rand;
|
||||
use std::hash::{self, SipHasher};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use test::Bencher;
|
||||
use test;
|
||||
|
||||
@ -1322,7 +1322,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_send() {
|
||||
let n = list_from(&[1,2,3]);
|
||||
Thread::scoped(move || {
|
||||
thread::spawn(move || {
|
||||
check_links(&n);
|
||||
let a: &[_] = &[&1,&2,&3];
|
||||
assert_eq!(a, n.iter().collect::<Vec<_>>());
|
||||
|
||||
@ -42,13 +42,13 @@
|
||||
//! ```
|
||||
//! use std::sync::Arc;
|
||||
//! use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! fn main() {
|
||||
//! let spinlock = Arc::new(AtomicUsize::new(1));
|
||||
//!
|
||||
//! let spinlock_clone = spinlock.clone();
|
||||
//! Thread::spawn(move|| {
|
||||
//! thread::spawn(move|| {
|
||||
//! spinlock_clone.store(0, Ordering::SeqCst);
|
||||
//! });
|
||||
//!
|
||||
|
||||
@ -375,9 +375,9 @@ impl<T> RefCell<T> {
|
||||
///
|
||||
/// ```
|
||||
/// 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 m = c.borrow_mut();
|
||||
///
|
||||
@ -436,9 +436,9 @@ impl<T> RefCell<T> {
|
||||
///
|
||||
/// ```
|
||||
/// 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 m = c.borrow_mut();
|
||||
///
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#![allow(deprecated)]
|
||||
|
||||
use core::finally::{try_finally, Finally};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
#[test]
|
||||
fn test_success() {
|
||||
@ -22,7 +22,7 @@ fn test_success() {
|
||||
*i = 10;
|
||||
},
|
||||
|i| {
|
||||
assert!(!Thread::panicking());
|
||||
assert!(!thread::panicking());
|
||||
assert_eq!(*i, 10);
|
||||
*i = 20;
|
||||
});
|
||||
@ -40,7 +40,7 @@ fn test_fail() {
|
||||
panic!();
|
||||
},
|
||||
|i| {
|
||||
assert!(Thread::panicking());
|
||||
assert!(thread::panicking());
|
||||
assert_eq!(*i, 10);
|
||||
})
|
||||
}
|
||||
|
||||
@ -365,7 +365,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
|
||||
let cr = Path::new(cratefile);
|
||||
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;
|
||||
|
||||
let cr = cr;
|
||||
|
||||
@ -15,7 +15,7 @@ use std::old_io::{Command, TempDir};
|
||||
use std::old_io;
|
||||
use std::env;
|
||||
use std::str;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::thunk::Thunk;
|
||||
|
||||
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 w2 = w1.clone();
|
||||
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 err = match old {
|
||||
Some(old) => {
|
||||
|
||||
@ -126,7 +126,7 @@ macro_rules! try {
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
/// use std::sync::mpsc;
|
||||
///
|
||||
/// // two placeholder functions for now
|
||||
@ -136,8 +136,8 @@ macro_rules! try {
|
||||
/// let (tx1, rx1) = mpsc::channel();
|
||||
/// let (tx2, rx2) = mpsc::channel();
|
||||
///
|
||||
/// Thread::spawn(move|| { long_running_task(); tx1.send(()).unwrap(); });
|
||||
/// Thread::spawn(move|| { tx2.send(calculate_the_answer()).unwrap(); });
|
||||
/// thread::spawn(move|| { long_running_task(); tx1.send(()).unwrap(); });
|
||||
/// thread::spawn(move|| { tx2.send(calculate_the_answer()).unwrap(); });
|
||||
///
|
||||
/// select! (
|
||||
/// _ = rx1.recv() => println!("the long running task finished first"),
|
||||
|
||||
@ -43,7 +43,7 @@ pub struct TcpStream(net_imp::TcpStream);
|
||||
///
|
||||
/// ```no_run
|
||||
/// use std::net::{TcpListener, TcpStream};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// 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() {
|
||||
/// match stream {
|
||||
/// Ok(stream) => {
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// // connection succeeded
|
||||
/// handle_client(stream)
|
||||
/// });
|
||||
@ -217,7 +217,7 @@ mod tests {
|
||||
use net::*;
|
||||
use net::test::{next_test_ip4, next_test_ip6};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
fn each_ip(f: &mut FnMut(SocketAddr)) {
|
||||
f(next_test_ip4());
|
||||
@ -257,7 +257,7 @@ mod tests {
|
||||
let socket_addr = next_test_ip4();
|
||||
let listener = t!(TcpListener::bind(&socket_addr));
|
||||
|
||||
let _t = Thread::scoped(move || {
|
||||
let _t = thread::spawn(move || {
|
||||
let mut stream = t!(TcpStream::connect(&("localhost",
|
||||
socket_addr.port())));
|
||||
t!(stream.write(&[144]));
|
||||
@ -274,7 +274,7 @@ mod tests {
|
||||
let addr = next_test_ip4();
|
||||
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())));
|
||||
t!(stream.write(&[44]));
|
||||
});
|
||||
@ -290,7 +290,7 @@ mod tests {
|
||||
let addr = next_test_ip6();
|
||||
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())));
|
||||
t!(stream.write(&[66]));
|
||||
});
|
||||
@ -307,7 +307,7 @@ mod tests {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = t!(TcpStream::connect(&addr));
|
||||
t!(stream.write(&[99]));
|
||||
tx.send(t!(stream.socket_addr())).unwrap();
|
||||
@ -326,7 +326,7 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _stream = t!(TcpStream::connect(&addr));
|
||||
// Close
|
||||
});
|
||||
@ -346,7 +346,7 @@ mod tests {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(t!(TcpStream::connect(&addr)));
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
@ -372,7 +372,7 @@ mod tests {
|
||||
let max = 10;
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0..max {
|
||||
let mut stream = t!(TcpStream::connect(&addr));
|
||||
t!(stream.write(&[99]));
|
||||
@ -394,11 +394,11 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let acceptor = acceptor;
|
||||
for (i, stream) in acceptor.incoming().enumerate().take(MAX) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = t!(stream);
|
||||
let mut buf = [0];
|
||||
t!(stream.read(&mut buf));
|
||||
@ -413,7 +413,7 @@ mod tests {
|
||||
fn connect(i: usize, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let t = Thread::scoped(move|| {
|
||||
let t = thread::spawn(move|| {
|
||||
let mut stream = t!(TcpStream::connect(&addr));
|
||||
// Connect again before writing
|
||||
connect(i + 1, addr);
|
||||
@ -429,10 +429,10 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for stream in acceptor.incoming().take(MAX) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = t!(stream);
|
||||
let mut buf = [0];
|
||||
t!(stream.read(&mut buf));
|
||||
@ -447,7 +447,7 @@ mod tests {
|
||||
fn connect(i: usize, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let t = Thread::scoped(move|| {
|
||||
let t = thread::spawn(move|| {
|
||||
let mut stream = t!(TcpStream::connect(&addr));
|
||||
connect(i + 1, addr);
|
||||
t!(stream.write(&[99]));
|
||||
@ -468,7 +468,7 @@ mod tests {
|
||||
let listener = t!(TcpListener::bind(&addr));
|
||||
let so_name = t!(listener.socket_addr());
|
||||
assert_eq!(addr, so_name);
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
t!(listener.accept());
|
||||
});
|
||||
|
||||
@ -482,7 +482,7 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let (tx, rx) = channel();
|
||||
let srv = t!(TcpListener::bind(&addr));
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut cl = t!(srv.accept()).0;
|
||||
cl.write(&[10]).unwrap();
|
||||
let mut b = [0];
|
||||
@ -518,7 +518,7 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let acceptor = t!(TcpListener::bind(&addr));
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
t!(TcpStream::connect(&addr));
|
||||
});
|
||||
|
||||
@ -533,7 +533,7 @@ mod tests {
|
||||
each_ip(&mut |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 buf = [0, 0];
|
||||
assert_eq!(s.read(&mut buf), Ok(1));
|
||||
@ -546,7 +546,7 @@ mod tests {
|
||||
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
rx1.recv().unwrap();
|
||||
t!(s2.write(&[1]));
|
||||
@ -566,7 +566,7 @@ mod tests {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s = t!(TcpStream::connect(&addr));
|
||||
t!(s.write(&[1]));
|
||||
rx.recv().unwrap();
|
||||
@ -578,7 +578,7 @@ mod tests {
|
||||
let s2 = t!(s1.try_clone());
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
let mut buf = [0, 0];
|
||||
t!(s2.read(&mut buf));
|
||||
@ -598,7 +598,7 @@ mod tests {
|
||||
each_ip(&mut |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 buf = [0, 1];
|
||||
t!(s.read(&mut buf));
|
||||
@ -609,7 +609,7 @@ mod tests {
|
||||
let s2 = t!(s1.try_clone());
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
t!(s2.write(&[1]));
|
||||
done.send(()).unwrap();
|
||||
@ -624,7 +624,7 @@ mod tests {
|
||||
fn shutdown_smoke() {
|
||||
each_ip(&mut |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 b = [0];
|
||||
assert_eq!(c.read(&mut b), Ok(0));
|
||||
@ -645,7 +645,7 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let a = t!(TcpListener::bind(&addr));
|
||||
let (tx, rx) = channel::<()>();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _s = t!(a.accept());
|
||||
let _ = rx.recv();
|
||||
});
|
||||
@ -683,7 +683,7 @@ mod tests {
|
||||
each_ip(&mut |addr| {
|
||||
let a = t!(TcpListener::bind(&addr));
|
||||
let (tx1, rx) = channel::<()>();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _s = t!(a.accept());
|
||||
let _ = rx.recv();
|
||||
});
|
||||
@ -691,7 +691,7 @@ mod tests {
|
||||
let s = t!(TcpStream::connect(&addr));
|
||||
let s2 = t!(s.try_clone());
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert_eq!(t!(s2.read(&mut [0])), 0);
|
||||
tx.send(()).unwrap();
|
||||
@ -714,7 +714,7 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let (txdone, rxdone) = channel();
|
||||
let txdone2 = txdone.clone();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut tcp = t!(TcpStream::connect(&addr));
|
||||
rx.recv().unwrap();
|
||||
t!(tcp.write(&[0]));
|
||||
@ -725,7 +725,7 @@ mod tests {
|
||||
let tcp = t!(accept.accept()).0;
|
||||
let tcp2 = t!(tcp.try_clone());
|
||||
let txdone3 = txdone.clone();
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut tcp2 = tcp2;
|
||||
t!(tcp2.read(&mut [0]));
|
||||
txdone3.send(()).unwrap();
|
||||
@ -733,7 +733,7 @@ mod tests {
|
||||
|
||||
// Try to ensure that the reading clone is indeed reading
|
||||
for _ in 0..50 {
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
}
|
||||
|
||||
// clone the handle again while it's reading, then let it finish the
|
||||
@ -751,10 +751,10 @@ mod tests {
|
||||
let a = t!(TcpListener::bind(&addr));
|
||||
let a2 = t!(a.try_clone());
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(&addr);
|
||||
});
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(&addr);
|
||||
});
|
||||
|
||||
@ -772,17 +772,17 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(t!(a.accept())).unwrap();
|
||||
});
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx2.send(t!(a2.accept())).unwrap();
|
||||
});
|
||||
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(&addr);
|
||||
});
|
||||
let _t = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(&addr);
|
||||
});
|
||||
|
||||
|
||||
@ -131,7 +131,7 @@ mod tests {
|
||||
use net::*;
|
||||
use net::test::{next_test_ip4, next_test_ip6};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
fn each_ip(f: &mut FnMut(SocketAddr, SocketAddr)) {
|
||||
f(next_test_ip4(), next_test_ip4());
|
||||
@ -164,7 +164,7 @@ mod tests {
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let client = t!(UdpSocket::bind(&client_ip));
|
||||
rx1.recv().unwrap();
|
||||
t!(client.send_to(&[99], &server_ip));
|
||||
@ -196,7 +196,7 @@ mod tests {
|
||||
let sock1 = t!(UdpSocket::bind(&addr1));
|
||||
let sock2 = t!(UdpSocket::bind(&addr2));
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut buf = [0, 0];
|
||||
assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
|
||||
assert_eq!(buf[0], 1);
|
||||
@ -207,7 +207,7 @@ mod tests {
|
||||
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx1.recv().unwrap();
|
||||
t!(sock3.send_to(&[1], &addr2));
|
||||
tx2.send(()).unwrap();
|
||||
@ -227,7 +227,7 @@ mod tests {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
t!(sock2.send_to(&[1], &addr1));
|
||||
rx.recv().unwrap();
|
||||
t!(sock2.send_to(&[2], &addr1));
|
||||
@ -237,7 +237,7 @@ mod tests {
|
||||
let sock3 = t!(sock1.try_clone());
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut buf = [0, 0];
|
||||
t!(sock3.recv_from(&mut buf));
|
||||
tx2.send(()).unwrap();
|
||||
@ -260,7 +260,7 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let (serv_tx, serv_rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut buf = [0, 1];
|
||||
rx.recv().unwrap();
|
||||
t!(sock2.recv_from(&mut buf));
|
||||
@ -271,7 +271,7 @@ mod tests {
|
||||
|
||||
let (done, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
match sock3.send_to(&[1], &addr2) {
|
||||
Ok(..) => { let _ = tx2.send(()); }
|
||||
Err(..) => {}
|
||||
|
||||
@ -161,12 +161,12 @@ mod test {
|
||||
use sync::mpsc::channel;
|
||||
use super::*;
|
||||
use old_io;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_rx_reader() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(vec![1u8, 2u8]).unwrap();
|
||||
tx.send(vec![]).unwrap();
|
||||
tx.send(vec![3u8, 4u8]).unwrap();
|
||||
@ -208,7 +208,7 @@ mod test {
|
||||
#[test]
|
||||
fn test_rx_buffer() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(b"he".to_vec()).unwrap();
|
||||
tx.send(b"llo wo".to_vec()).unwrap();
|
||||
tx.send(b"".to_vec()).unwrap();
|
||||
@ -234,7 +234,7 @@ mod test {
|
||||
writer.write_be_u32(42).unwrap();
|
||||
|
||||
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,
|
||||
Err(_) => panic!(),
|
||||
};
|
||||
|
||||
@ -124,7 +124,7 @@
|
||||
//! # #![allow(dead_code)]
|
||||
//! use std::old_io::{TcpListener, TcpStream};
|
||||
//! use std::old_io::{Acceptor, Listener};
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! let listener = TcpListener::bind("127.0.0.1:80");
|
||||
//!
|
||||
@ -140,7 +140,7 @@
|
||||
//! match stream {
|
||||
//! Err(e) => { /* connection failed */ }
|
||||
//! Ok(stream) => {
|
||||
//! Thread::spawn(move|| {
|
||||
//! thread::spawn(move|| {
|
||||
//! // connection succeeded
|
||||
//! handle_client(stream)
|
||||
//! });
|
||||
|
||||
@ -282,7 +282,7 @@ mod tests {
|
||||
use old_io::test::*;
|
||||
use super::*;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use time::Duration;
|
||||
|
||||
pub fn smalltest<F,G>(server: F, client: G)
|
||||
@ -294,7 +294,7 @@ mod tests {
|
||||
|
||||
let mut acceptor = UnixListener::bind(&path1).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
match UnixStream::connect(&path2) {
|
||||
Ok(c) => client(c),
|
||||
Err(e) => panic!("failed connect: {}", e),
|
||||
@ -389,7 +389,7 @@ mod tests {
|
||||
Err(e) => panic!("failed listen: {}", e),
|
||||
};
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0u..times {
|
||||
let mut stream = UnixStream::connect(&path2);
|
||||
match stream.write(&[100]) {
|
||||
@ -423,7 +423,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
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 buf = [0, 0];
|
||||
debug!("client reading");
|
||||
@ -439,7 +439,7 @@ mod tests {
|
||||
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
rx1.recv().unwrap();
|
||||
debug!("writer writing");
|
||||
@ -462,7 +462,7 @@ mod tests {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr);
|
||||
s.write(&[1]).unwrap();
|
||||
rx.recv().unwrap();
|
||||
@ -474,7 +474,7 @@ mod tests {
|
||||
let s2 = s1.clone();
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
let mut buf = [0, 0];
|
||||
s2.read(&mut buf).unwrap();
|
||||
@ -493,7 +493,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let mut acceptor = UnixListener::bind(&addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr);
|
||||
let buf = &mut [0, 1];
|
||||
s.read(buf).unwrap();
|
||||
@ -504,7 +504,7 @@ mod tests {
|
||||
let s2 = s1.clone();
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
s2.write(&[1]).unwrap();
|
||||
tx.send(()).unwrap();
|
||||
@ -551,7 +551,7 @@ mod tests {
|
||||
// continue to receive any pending connections.
|
||||
let (tx, rx) = channel();
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(UnixStream::connect(&addr2).unwrap()).unwrap();
|
||||
});
|
||||
let l = rx.recv().unwrap();
|
||||
@ -561,7 +561,7 @@ mod tests {
|
||||
Err(ref e) if e.kind == TimedOut => {}
|
||||
Err(e) => panic!("error: {}", e),
|
||||
}
|
||||
::thread::Thread::yield_now();
|
||||
::thread::yield_now();
|
||||
if i == 1000 { panic!("should have a pending connection") }
|
||||
}
|
||||
drop(l);
|
||||
@ -569,7 +569,7 @@ mod tests {
|
||||
// Unset the timeout and make sure that this always blocks.
|
||||
a.set_timeout(None);
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(UnixStream::connect(&addr2).unwrap());
|
||||
});
|
||||
a.accept().unwrap();
|
||||
@ -607,7 +607,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (_tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv();
|
||||
@ -644,7 +644,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (_tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv();
|
||||
@ -653,7 +653,7 @@ mod tests {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
let s2 = s.clone();
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_err());
|
||||
tx.send(()).unwrap();
|
||||
@ -670,7 +670,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let mut a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
@ -708,7 +708,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let mut a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
let mut amt = 0;
|
||||
@ -737,7 +737,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let mut a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
@ -764,7 +764,7 @@ mod tests {
|
||||
let addr = next_test_unix();
|
||||
let mut a = UnixListener::bind(&addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
@ -774,7 +774,7 @@ mod tests {
|
||||
let mut s = a.accept().unwrap();
|
||||
let s2 = s.clone();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_ok());
|
||||
tx2.send(()).unwrap();
|
||||
@ -796,10 +796,10 @@ mod tests {
|
||||
let mut a2 = a.clone();
|
||||
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = UnixStream::connect(&addr2);
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = UnixStream::connect(&addr);
|
||||
});
|
||||
|
||||
@ -819,20 +819,20 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap()
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a2;
|
||||
tx2.send(a.accept()).unwrap()
|
||||
});
|
||||
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = UnixStream::connect(&addr2);
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = UnixStream::connect(&addr);
|
||||
});
|
||||
|
||||
@ -858,7 +858,7 @@ mod tests {
|
||||
let mut a2 = a.clone();
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
|
||||
@ -137,12 +137,12 @@ impl TcpStream {
|
||||
/// use std::old_io::timer;
|
||||
/// use std::old_io::TcpStream;
|
||||
/// use std::time::Duration;
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
|
||||
/// let stream2 = stream.clone();
|
||||
///
|
||||
/// let _t = Thread::spawn(move|| {
|
||||
/// let _t = thread::spawn(move|| {
|
||||
/// // close this stream after one second
|
||||
/// timer::sleep(Duration::seconds(1));
|
||||
/// let mut stream = stream2;
|
||||
@ -282,7 +282,7 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
|
||||
/// # fn foo() {
|
||||
/// use std::old_io::{TcpListener, TcpStream};
|
||||
/// use std::old_io::{Acceptor, Listener};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
|
||||
///
|
||||
@ -298,7 +298,7 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
|
||||
/// match stream {
|
||||
/// Err(e) => { /* connection failed */ }
|
||||
/// Ok(stream) => {
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// // connection succeeded
|
||||
/// handle_client(stream)
|
||||
/// });
|
||||
@ -421,12 +421,12 @@ impl TcpAcceptor {
|
||||
///
|
||||
/// ```
|
||||
/// 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 a2 = a.clone();
|
||||
///
|
||||
/// let _t = Thread::spawn(move|| {
|
||||
/// let _t = thread::spawn(move|| {
|
||||
/// let mut a2 = a2;
|
||||
/// for socket in a2.incoming() {
|
||||
/// match socket {
|
||||
@ -487,7 +487,7 @@ mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use old_io::net::tcp::*;
|
||||
use old_io::net::ip::*;
|
||||
use old_io::test::*;
|
||||
@ -522,7 +522,7 @@ mod test {
|
||||
let listener = TcpListener::bind(socket_addr);
|
||||
let mut acceptor = listener.listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = TcpStream::connect(("localhost", socket_addr.port));
|
||||
stream.write(&[144]).unwrap();
|
||||
});
|
||||
@ -538,7 +538,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
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));
|
||||
stream.write(&[64]).unwrap();
|
||||
});
|
||||
@ -554,7 +554,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
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));
|
||||
stream.write(&[44]).unwrap();
|
||||
});
|
||||
@ -570,7 +570,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
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));
|
||||
stream.write(&[66]).unwrap();
|
||||
});
|
||||
@ -586,7 +586,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
stream.write(&[99]).unwrap();
|
||||
});
|
||||
@ -602,7 +602,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
stream.write(&[99]).unwrap();
|
||||
});
|
||||
@ -618,7 +618,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _stream = TcpStream::connect(addr);
|
||||
// Close
|
||||
});
|
||||
@ -634,7 +634,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _stream = TcpStream::connect(addr);
|
||||
// Close
|
||||
});
|
||||
@ -650,7 +650,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _stream = TcpStream::connect(addr);
|
||||
// Close
|
||||
});
|
||||
@ -674,7 +674,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _stream = TcpStream::connect(addr);
|
||||
// Close
|
||||
});
|
||||
@ -699,7 +699,7 @@ mod test {
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(TcpStream::connect(addr));
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
@ -724,7 +724,7 @@ mod test {
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(TcpStream::connect(addr));
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
@ -749,7 +749,7 @@ mod test {
|
||||
let max = 10u;
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0..max {
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
stream.write(&[99]).unwrap();
|
||||
@ -769,7 +769,7 @@ mod test {
|
||||
let max = 10u;
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0..max {
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
stream.write(&[99]).unwrap();
|
||||
@ -789,11 +789,11 @@ mod test {
|
||||
static MAX: int = 10;
|
||||
let acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acceptor = acceptor;
|
||||
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = stream;
|
||||
let mut buf = [0];
|
||||
stream.read(&mut buf).unwrap();
|
||||
@ -808,7 +808,7 @@ mod test {
|
||||
fn connect(i: int, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
debug!("connecting");
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
// Connect again before writing
|
||||
@ -825,11 +825,11 @@ mod test {
|
||||
static MAX: int = 10;
|
||||
let acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acceptor = acceptor;
|
||||
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = stream;
|
||||
let mut buf = [0];
|
||||
stream.read(&mut buf).unwrap();
|
||||
@ -844,7 +844,7 @@ mod test {
|
||||
fn connect(i: int, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
debug!("connecting");
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
// Connect again before writing
|
||||
@ -861,11 +861,11 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acceptor = acceptor;
|
||||
for stream in acceptor.incoming().take(MAX as uint) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = stream;
|
||||
let mut buf = [0];
|
||||
stream.read(&mut buf).unwrap();
|
||||
@ -880,7 +880,7 @@ mod test {
|
||||
fn connect(i: int, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
debug!("connecting");
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
// Connect again before writing
|
||||
@ -897,11 +897,11 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let acceptor = TcpListener::bind(addr).listen();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acceptor = acceptor;
|
||||
for stream in acceptor.incoming().take(MAX as uint) {
|
||||
// Start another task to handle the connection
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut stream = stream;
|
||||
let mut buf = [0];
|
||||
stream.read(&mut buf).unwrap();
|
||||
@ -916,7 +916,7 @@ mod test {
|
||||
fn connect(i: int, addr: SocketAddr) {
|
||||
if i == MAX { return }
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
debug!("connecting");
|
||||
let mut stream = TcpStream::connect(addr);
|
||||
// Connect again before writing
|
||||
@ -939,7 +939,7 @@ mod test {
|
||||
|
||||
pub fn peer_name(addr: SocketAddr) {
|
||||
let acceptor = TcpListener::bind(addr).listen();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acceptor = acceptor;
|
||||
acceptor.accept().unwrap();
|
||||
});
|
||||
@ -974,7 +974,7 @@ mod test {
|
||||
fn partial_read() {
|
||||
let addr = next_test_ip4();
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut srv = TcpListener::bind(addr).listen().unwrap();
|
||||
tx.send(()).unwrap();
|
||||
let mut cl = srv.accept().unwrap();
|
||||
@ -1011,7 +1011,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let (tx, rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
let _stream = TcpStream::connect(addr).unwrap();
|
||||
// Close
|
||||
@ -1036,7 +1036,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
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 buf = [0, 0];
|
||||
assert_eq!(s.read(&mut buf), Ok(1));
|
||||
@ -1049,7 +1049,7 @@ mod test {
|
||||
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
rx1.recv().unwrap();
|
||||
s2.write(&[1]).unwrap();
|
||||
@ -1068,7 +1068,7 @@ mod test {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr);
|
||||
s.write(&[1]).unwrap();
|
||||
rx.recv().unwrap();
|
||||
@ -1080,7 +1080,7 @@ mod test {
|
||||
let s2 = s1.clone();
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
let mut buf = [0, 0];
|
||||
s2.read(&mut buf).unwrap();
|
||||
@ -1099,7 +1099,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
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 buf = [0, 1];
|
||||
s.read(&mut buf).unwrap();
|
||||
@ -1110,7 +1110,7 @@ mod test {
|
||||
let s2 = s1.clone();
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
s2.write(&[1]).unwrap();
|
||||
done.send(()).unwrap();
|
||||
@ -1124,7 +1124,7 @@ mod test {
|
||||
fn shutdown_smoke() {
|
||||
let addr = next_test_ip4();
|
||||
let a = TcpListener::bind(addr).unwrap().listen();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let mut c = a.accept().unwrap();
|
||||
assert_eq!(c.read_to_end(), Ok(vec!()));
|
||||
@ -1158,7 +1158,7 @@ mod test {
|
||||
// flakiness.
|
||||
if !cfg!(target_os = "freebsd") {
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(TcpStream::connect(addr).unwrap()).unwrap();
|
||||
});
|
||||
let _l = rx.recv().unwrap();
|
||||
@ -1168,14 +1168,14 @@ mod test {
|
||||
Err(ref e) if e.kind == TimedOut => {}
|
||||
Err(e) => panic!("error: {}", e),
|
||||
}
|
||||
::thread::Thread::yield_now();
|
||||
::thread::yield_now();
|
||||
if i == 1000 { panic!("should have a pending connection") }
|
||||
}
|
||||
}
|
||||
|
||||
// Unset the timeout and make sure that this always blocks.
|
||||
a.set_timeout(None);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(TcpStream::connect(addr).unwrap());
|
||||
});
|
||||
a.accept().unwrap();
|
||||
@ -1186,7 +1186,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (_tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv().unwrap();
|
||||
@ -1223,7 +1223,7 @@ mod test {
|
||||
let addr = next_test_ip4();
|
||||
let a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (_tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv().unwrap();
|
||||
@ -1232,7 +1232,7 @@ mod test {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
let s2 = s.clone();
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_err());
|
||||
tx.send(()).unwrap();
|
||||
@ -1249,7 +1249,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
@ -1282,7 +1282,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
let mut amt = 0;
|
||||
@ -1311,7 +1311,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
@ -1339,7 +1339,7 @@ mod test {
|
||||
let addr = next_test_ip6();
|
||||
let mut a = TcpListener::bind(addr).listen().unwrap();
|
||||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
assert_eq!(s.write(&[0]), Ok(()));
|
||||
@ -1349,7 +1349,7 @@ mod test {
|
||||
let mut s = a.accept().unwrap();
|
||||
let s2 = s.clone();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert_eq!(s2.read(&mut [0]), Ok(1));
|
||||
tx2.send(()).unwrap();
|
||||
@ -1372,7 +1372,7 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
let (txdone, rxdone) = channel();
|
||||
let txdone2 = txdone.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut tcp = TcpStream::connect(addr).unwrap();
|
||||
rx.recv().unwrap();
|
||||
tcp.write_u8(0).unwrap();
|
||||
@ -1383,7 +1383,7 @@ mod test {
|
||||
let tcp = accept.accept().unwrap();
|
||||
let tcp2 = tcp.clone();
|
||||
let txdone3 = txdone.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut tcp2 = tcp2;
|
||||
tcp2.read_u8().unwrap();
|
||||
txdone3.send(()).unwrap();
|
||||
@ -1391,7 +1391,7 @@ mod test {
|
||||
|
||||
// Try to ensure that the reading clone is indeed reading
|
||||
for _ in 0..50 {
|
||||
::thread::Thread::yield_now();
|
||||
::thread::yield_now();
|
||||
}
|
||||
|
||||
// clone the handle again while it's reading, then let it finish the
|
||||
@ -1409,10 +1409,10 @@ mod test {
|
||||
let mut a = l.listen().unwrap();
|
||||
let mut a2 = a.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(addr);
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(addr);
|
||||
});
|
||||
|
||||
@ -1430,19 +1430,19 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a2;
|
||||
tx2.send(a.accept()).unwrap();
|
||||
});
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(addr);
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(addr);
|
||||
});
|
||||
|
||||
@ -1468,7 +1468,7 @@ mod test {
|
||||
let mut a2 = a.clone();
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
|
||||
@ -186,7 +186,7 @@ mod test {
|
||||
use old_io::test::*;
|
||||
use old_io::{IoError, TimedOut, PermissionDenied, ShortWrite};
|
||||
use super::*;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
// FIXME #11530 this fails on android because tests are run as root
|
||||
#[cfg_attr(any(windows, target_os = "android"), ignore)]
|
||||
@ -206,7 +206,7 @@ mod test {
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
match UdpSocket::bind(client_ip) {
|
||||
Ok(ref mut client) => {
|
||||
rx1.recv().unwrap();
|
||||
@ -241,7 +241,7 @@ mod test {
|
||||
let client_ip = next_test_ip6();
|
||||
let (tx, rx) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
match UdpSocket::bind(client_ip) {
|
||||
Ok(ref mut client) => {
|
||||
rx.recv().unwrap();
|
||||
@ -298,7 +298,7 @@ mod test {
|
||||
let mut sock1 = UdpSocket::bind(addr1).unwrap();
|
||||
let sock2 = UdpSocket::bind(addr2).unwrap();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock2 = sock2;
|
||||
let mut buf = [0, 0];
|
||||
assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
|
||||
@ -310,7 +310,7 @@ mod test {
|
||||
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock3 = sock3;
|
||||
rx1.recv().unwrap();
|
||||
sock3.send_to(&[1], addr2).unwrap();
|
||||
@ -331,7 +331,7 @@ mod test {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock2 = sock2;
|
||||
sock2.send_to(&[1], addr1).unwrap();
|
||||
rx.recv().unwrap();
|
||||
@ -342,7 +342,7 @@ mod test {
|
||||
let sock3 = sock1.clone();
|
||||
|
||||
let (done, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock3 = sock3;
|
||||
let mut buf = [0, 0];
|
||||
sock3.recv_from(&mut buf).unwrap();
|
||||
@ -366,7 +366,7 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
let (serv_tx, serv_rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock2 = sock2;
|
||||
let mut buf = [0, 1];
|
||||
|
||||
@ -382,7 +382,7 @@ mod test {
|
||||
|
||||
let (done, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut sock3 = sock3;
|
||||
match sock3.send_to(&[1], addr2) {
|
||||
Ok(..) => { let _ = tx2.send(()); }
|
||||
@ -410,7 +410,7 @@ mod test {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut a = a2;
|
||||
assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1)));
|
||||
assert_eq!(a.send_to(&[0], addr1), Ok(()));
|
||||
|
||||
@ -115,7 +115,7 @@ mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn partial_read() {
|
||||
@ -126,7 +126,7 @@ mod test {
|
||||
let out = PipeStream::open(writer);
|
||||
let mut input = PipeStream::open(reader);
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut out = out;
|
||||
out.write(&[10]).unwrap();
|
||||
rx.recv().unwrap(); // don't close the pipe until the other read has finished
|
||||
|
||||
@ -30,7 +30,7 @@ use sync::mpsc::{channel, Receiver};
|
||||
use sys::fs::FileDesc;
|
||||
use sys::process::Process as ProcessImp;
|
||||
use sys;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[cfg(windows)] use hash;
|
||||
#[cfg(windows)] use str;
|
||||
@ -703,7 +703,7 @@ impl Process {
|
||||
let (tx, rx) = channel();
|
||||
match stream {
|
||||
Some(stream) => {
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
let mut stream = stream;
|
||||
tx.send(stream.read_to_end()).unwrap();
|
||||
});
|
||||
@ -764,7 +764,7 @@ mod tests {
|
||||
use super::{CreatePipe};
|
||||
use super::{InheritFd, Process, PleaseExitSignal, Command, ProcessOutput};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use time::Duration;
|
||||
|
||||
// FIXME(#10380) these tests should not all be ignored on android.
|
||||
@ -1169,14 +1169,14 @@ mod tests {
|
||||
fn wait_timeout2() {
|
||||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut p = sleeper();
|
||||
p.set_timeout(Some(10));
|
||||
assert_eq!(p.wait().err().unwrap().kind, TimedOut);
|
||||
p.signal_kill().unwrap();
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut p = sleeper();
|
||||
p.set_timeout(Some(10));
|
||||
assert_eq!(p.wait().err().unwrap().kind, TimedOut);
|
||||
|
||||
@ -530,7 +530,7 @@ mod tests {
|
||||
|
||||
use super::*;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn smoke() {
|
||||
@ -546,7 +546,7 @@ mod tests {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
set_stdout(box w);
|
||||
println!("hello!");
|
||||
});
|
||||
@ -559,7 +559,7 @@ mod tests {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
|
||||
let _t = Thread::spawn(move || -> () {
|
||||
let _t = thread::spawn(move || -> () {
|
||||
set_stderr(box w);
|
||||
panic!("my special message");
|
||||
});
|
||||
|
||||
@ -224,13 +224,13 @@ fn in_ms_u64(d: Duration) -> u64 {
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::Timer;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use time::Duration;
|
||||
|
||||
#[test]
|
||||
fn test_timer_send() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
Thread::spawn(move || timer.sleep(Duration::milliseconds(1)));
|
||||
thread::spawn(move || timer.sleep(Duration::milliseconds(1)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -360,7 +360,7 @@ mod test {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let _ = timer_rx.recv();
|
||||
});
|
||||
|
||||
@ -374,7 +374,7 @@ mod test {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let _ = timer_rx.recv();
|
||||
});
|
||||
|
||||
@ -387,7 +387,7 @@ mod test {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let _ = timer_rx.recv();
|
||||
});
|
||||
|
||||
|
||||
@ -518,18 +518,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_null_byte() {
|
||||
use thread::Thread;
|
||||
let result = Thread::scoped(move|| {
|
||||
use thread;
|
||||
let result = thread::spawn(move|| {
|
||||
Path::new(b"foo/bar\0")
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = Thread::scoped(move|| {
|
||||
let result = thread::spawn(move|| {
|
||||
Path::new("test").set_filename(b"f\0o")
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = Thread::scoped(move|| {
|
||||
let result = thread::spawn(move|| {
|
||||
Path::new("test").push(b"f\0o");
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
@ -1305,18 +1305,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_null_byte() {
|
||||
use thread::Thread;
|
||||
let result = Thread::scoped(move|| {
|
||||
use thread;
|
||||
let result = thread::spawn(move|| {
|
||||
Path::new(b"foo/bar\0")
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = Thread::scoped(move|| {
|
||||
let result = thread::spawn(move|| {
|
||||
Path::new("test").set_filename(b"f\0o")
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = Thread::scoped(move || {
|
||||
let result = thread::spawn(move || {
|
||||
Path::new("test").push(b"f\0o");
|
||||
}).join();
|
||||
assert!(result.is_err());
|
||||
|
||||
@ -17,7 +17,7 @@ use cell::RefCell;
|
||||
use old_io::IoResult;
|
||||
use rt::{backtrace, unwind};
|
||||
use rt::util::{Stderr, Stdio};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
// Defined in this module instead of old_io::stdio so that the unwinding
|
||||
thread_local! {
|
||||
@ -42,7 +42,7 @@ pub fn on_panic(obj: &(Any+Send), file: &'static str, line: uint) {
|
||||
}
|
||||
};
|
||||
let mut err = Stderr;
|
||||
let thread = Thread::current();
|
||||
let thread = thread::current();
|
||||
let name = thread.name().unwrap_or("<unnamed>");
|
||||
let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take());
|
||||
match prev {
|
||||
|
||||
@ -27,7 +27,7 @@ use sys::process2::Process as ProcessImp;
|
||||
use sys::process2::Command as CommandImp;
|
||||
use sys::process2::ExitStatus as ExitStatusImp;
|
||||
use sys_common::{AsInner, AsInnerMut};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
/// Representation of a running or exited child process.
|
||||
///
|
||||
@ -462,7 +462,7 @@ impl Child {
|
||||
let (tx, rx) = channel();
|
||||
match stream {
|
||||
Some(stream) => {
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
let mut stream = stream;
|
||||
let mut ret = Vec::new();
|
||||
let res = stream.read_to_end(&mut ret);
|
||||
@ -499,7 +499,7 @@ mod tests {
|
||||
use str;
|
||||
use super::{Child, Command, Output, ExitStatus, Stdio};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use time::Duration;
|
||||
|
||||
// FIXME(#10380) these tests should not all be ignored on android.
|
||||
|
||||
@ -360,7 +360,7 @@ mod test {
|
||||
use sync::mpsc::channel;
|
||||
use rand::Rng;
|
||||
use super::OsRng;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_os_rng() {
|
||||
@ -381,23 +381,23 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
txs.push(tx);
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
// wait until all the tasks are ready to go.
|
||||
rx.recv().unwrap();
|
||||
|
||||
// deschedule to attempt to interleave things as much
|
||||
// as possible (XXX: is this a good test?)
|
||||
let mut r = OsRng::new().unwrap();
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
let mut v = [0u8; 1000];
|
||||
|
||||
for _ in 0u..100 {
|
||||
r.next_u32();
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
r.next_u64();
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
r.fill_bytes(&mut v);
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@ -149,7 +149,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
|
||||
}
|
||||
|
||||
pub unsafe fn report_overflow() {
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
// See the message below for why this is not emitted to the
|
||||
// ^ 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.
|
||||
|
||||
rterrln!("\nthread '{}' has overflowed its stack",
|
||||
Thread::current().name().unwrap_or("<unknown>"));
|
||||
thread::current().name().unwrap_or("<unknown>"));
|
||||
}
|
||||
|
||||
@ -15,14 +15,14 @@ use sync::{Mutex, Condvar};
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::sync::{Arc, Barrier};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let barrier = Arc::new(Barrier::new(10));
|
||||
/// for _ in 0u..10 {
|
||||
/// let c = barrier.clone();
|
||||
/// // The same messages will be printed together.
|
||||
/// // You will NOT see any interleaving.
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// println!("before wait");
|
||||
/// c.wait();
|
||||
/// println!("after wait");
|
||||
@ -111,7 +111,7 @@ mod tests {
|
||||
|
||||
use sync::{Arc, Barrier};
|
||||
use sync::mpsc::{channel, TryRecvError};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_barrier() {
|
||||
@ -123,7 +123,7 @@ mod tests {
|
||||
for _ in 0u..N - 1 {
|
||||
let c = barrier.clone();
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(c.wait().is_leader()).unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
@ -38,13 +38,13 @@ use sync::{mutex, MutexGuard, PoisonError};
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::{Arc, Mutex, Condvar};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||
/// let pair2 = pair.clone();
|
||||
///
|
||||
/// // 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 mut started = lock.lock().unwrap();
|
||||
/// *started = true;
|
||||
@ -353,7 +353,7 @@ mod tests {
|
||||
use sync::mpsc::channel;
|
||||
use sync::{StaticMutex, MUTEX_INIT, Condvar, Mutex, Arc};
|
||||
use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use time::Duration;
|
||||
|
||||
#[test]
|
||||
@ -377,7 +377,7 @@ mod tests {
|
||||
static M: StaticMutex = MUTEX_INIT;
|
||||
|
||||
let g = M.lock().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _g = M.lock().unwrap();
|
||||
C.notify_one();
|
||||
});
|
||||
@ -395,7 +395,7 @@ mod tests {
|
||||
for _ in 0..N {
|
||||
let data = data.clone();
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let &(ref lock, ref cond) = &*data;
|
||||
let mut cnt = lock.lock().unwrap();
|
||||
*cnt += 1;
|
||||
@ -431,7 +431,7 @@ mod tests {
|
||||
let (g, _no_timeout) = C.wait_timeout(g, Duration::nanoseconds(1000)).unwrap();
|
||||
// spurious wakeups mean this isn't necessarily true
|
||||
// assert!(!no_timeout);
|
||||
let _t = Thread::spawn(move || {
|
||||
let _t = thread::spawn(move || {
|
||||
let _g = M.lock().unwrap();
|
||||
C.notify_one();
|
||||
});
|
||||
@ -452,7 +452,7 @@ mod tests {
|
||||
assert!(!success);
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::scoped(move || {
|
||||
let _t = thread::spawn(move || {
|
||||
rx.recv().unwrap();
|
||||
let g = M.lock().unwrap();
|
||||
S.store(1, Ordering::SeqCst);
|
||||
@ -492,7 +492,7 @@ mod tests {
|
||||
static C: StaticCondvar = CONDVAR_INIT;
|
||||
|
||||
let mut g = M1.lock().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _g = M1.lock().unwrap();
|
||||
C.notify_one();
|
||||
});
|
||||
|
||||
@ -38,7 +38,7 @@ use core::mem::replace;
|
||||
use self::FutureState::*;
|
||||
use sync::mpsc::{Receiver, channel};
|
||||
use thunk::{Thunk};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
/// A type encapsulating the result of a computation which may not be complete
|
||||
pub struct Future<A> {
|
||||
@ -143,7 +143,7 @@ impl<A:Send> Future<A> {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
// Don't panic if the other end has hung up
|
||||
let _ = tx.send(blk());
|
||||
});
|
||||
@ -157,7 +157,7 @@ mod test {
|
||||
use prelude::v1::*;
|
||||
use sync::mpsc::channel;
|
||||
use sync::Future;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_from_value() {
|
||||
@ -215,7 +215,7 @@ mod test {
|
||||
let expected = "schlorf";
|
||||
let (tx, rx) = channel();
|
||||
let f = Future::spawn(move|| { expected });
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut f = f;
|
||||
tx.send(f.get()).unwrap();
|
||||
});
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
//! Generic support for building blocking abstractions.
|
||||
|
||||
use thread::Thread;
|
||||
use thread::{self, Thread};
|
||||
use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
|
||||
use sync::Arc;
|
||||
use marker::{Sync, Send};
|
||||
@ -40,7 +40,7 @@ impl !Sync for WaitToken {}
|
||||
|
||||
pub fn tokens() -> (WaitToken, SignalToken) {
|
||||
let inner = Arc::new(Inner {
|
||||
thread: Thread::current(),
|
||||
thread: thread::current(),
|
||||
woken: ATOMIC_BOOL_INIT,
|
||||
});
|
||||
let wait_token = WaitToken {
|
||||
@ -80,7 +80,7 @@ impl SignalToken {
|
||||
impl WaitToken {
|
||||
pub fn wait(self) {
|
||||
while !self.inner.woken.load(Ordering::SeqCst) {
|
||||
Thread::park()
|
||||
thread::park()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -53,12 +53,12 @@
|
||||
//! Simple usage:
|
||||
//!
|
||||
//! ```
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//! use std::sync::mpsc::channel;
|
||||
//!
|
||||
//! // Create a simple streaming channel
|
||||
//! let (tx, rx) = channel();
|
||||
//! Thread::spawn(move|| {
|
||||
//! thread::spawn(move|| {
|
||||
//! tx.send(10).unwrap();
|
||||
//! });
|
||||
//! assert_eq!(rx.recv().unwrap(), 10);
|
||||
@ -67,7 +67,7 @@
|
||||
//! Shared usage:
|
||||
//!
|
||||
//! ```
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//! use std::sync::mpsc::channel;
|
||||
//!
|
||||
//! // Create a shared channel that can be sent along from many threads
|
||||
@ -76,7 +76,7 @@
|
||||
//! let (tx, rx) = channel();
|
||||
//! for i in 0..10 {
|
||||
//! let tx = tx.clone();
|
||||
//! Thread::spawn(move|| {
|
||||
//! thread::spawn(move|| {
|
||||
//! tx.send(i).unwrap();
|
||||
//! });
|
||||
//! }
|
||||
@ -102,11 +102,11 @@
|
||||
//! Synchronous channels:
|
||||
//!
|
||||
//! ```
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//! use std::sync::mpsc::sync_channel;
|
||||
//!
|
||||
//! let (tx, rx) = sync_channel::<int>(0);
|
||||
//! Thread::spawn(move|| {
|
||||
//! thread::spawn(move|| {
|
||||
//! // This will wait for the parent task to start receiving
|
||||
//! tx.send(53).unwrap();
|
||||
//! });
|
||||
@ -467,14 +467,14 @@ impl<T> UnsafeFlavor<T> for Receiver<T> {
|
||||
///
|
||||
/// ```
|
||||
/// 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
|
||||
/// // half (rx for receiving).
|
||||
/// let (tx, rx) = channel();
|
||||
///
|
||||
/// // Spawn off an expensive computation
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// # fn expensive_computation() {}
|
||||
/// 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::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let (tx, rx) = sync_channel(1);
|
||||
///
|
||||
/// // this returns immediately
|
||||
/// tx.send(1).unwrap();
|
||||
///
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// // this will block until the previous message has been received
|
||||
/// tx.send(2).unwrap();
|
||||
/// });
|
||||
@ -1026,7 +1026,7 @@ mod test {
|
||||
|
||||
use std::env;
|
||||
use super::*;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
pub fn stress_factor() -> uint {
|
||||
match env::var("RUST_TEST_STRESS") {
|
||||
@ -1069,7 +1069,7 @@ mod test {
|
||||
#[test]
|
||||
fn smoke_threads() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
assert_eq!(rx.recv().unwrap(), 1);
|
||||
@ -1101,7 +1101,7 @@ mod test {
|
||||
#[test]
|
||||
fn port_gone_concurrent() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
while tx.send(1).is_ok() {}
|
||||
@ -1111,7 +1111,7 @@ mod test {
|
||||
fn port_gone_concurrent_shared() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let tx2 = tx.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
|
||||
@ -1136,7 +1136,7 @@ mod test {
|
||||
#[test]
|
||||
fn chan_gone_concurrent() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(1).unwrap();
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
@ -1146,7 +1146,7 @@ mod test {
|
||||
#[test]
|
||||
fn stress() {
|
||||
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 {
|
||||
@ -1161,7 +1161,7 @@ mod test {
|
||||
static NTHREADS: uint = 8;
|
||||
let (tx, rx) = channel::<int>();
|
||||
|
||||
let t = Thread::scoped(move|| {
|
||||
let t = thread::spawn(move|| {
|
||||
for _ in 0..AMT * NTHREADS {
|
||||
assert_eq!(rx.recv().unwrap(), 1);
|
||||
}
|
||||
@ -1173,7 +1173,7 @@ mod test {
|
||||
|
||||
for _ in 0..NTHREADS {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
for _ in 0..AMT { tx.send(1).unwrap(); }
|
||||
});
|
||||
}
|
||||
@ -1185,14 +1185,14 @@ mod test {
|
||||
fn send_from_outside_runtime() {
|
||||
let (tx1, rx1) = channel::<()>();
|
||||
let (tx2, rx2) = channel::<int>();
|
||||
let t1 = Thread::scoped(move|| {
|
||||
let t1 = thread::spawn(move|| {
|
||||
tx1.send(()).unwrap();
|
||||
for _ in 0..40 {
|
||||
assert_eq!(rx2.recv().unwrap(), 1);
|
||||
}
|
||||
});
|
||||
rx1.recv().unwrap();
|
||||
let t2 = Thread::scoped(move|| {
|
||||
let t2 = thread::spawn(move|| {
|
||||
for _ in 0..40 {
|
||||
tx2.send(1).unwrap();
|
||||
}
|
||||
@ -1204,7 +1204,7 @@ mod test {
|
||||
#[test]
|
||||
fn recv_from_outside_runtime() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let t = Thread::scoped(move|| {
|
||||
let t = thread::spawn(move|| {
|
||||
for _ in 0..40 {
|
||||
assert_eq!(rx.recv().unwrap(), 1);
|
||||
}
|
||||
@ -1219,11 +1219,11 @@ mod test {
|
||||
fn no_runtime() {
|
||||
let (tx1, rx1) = channel::<int>();
|
||||
let (tx2, rx2) = channel::<int>();
|
||||
let t1 = Thread::scoped(move|| {
|
||||
let t1 = thread::spawn(move|| {
|
||||
assert_eq!(rx1.recv().unwrap(), 1);
|
||||
tx2.send(2).unwrap();
|
||||
});
|
||||
let t2 = Thread::scoped(move|| {
|
||||
let t2 = thread::spawn(move|| {
|
||||
tx1.send(1).unwrap();
|
||||
assert_eq!(rx2.recv().unwrap(), 2);
|
||||
});
|
||||
@ -1256,7 +1256,7 @@ mod test {
|
||||
#[test]
|
||||
fn oneshot_single_thread_recv_chan_close() {
|
||||
// Receiving on a closed chan will panic
|
||||
let res = Thread::scoped(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
let (tx, rx) = channel::<int>();
|
||||
drop(tx);
|
||||
rx.recv().unwrap();
|
||||
@ -1325,7 +1325,7 @@ mod test {
|
||||
#[test]
|
||||
fn oneshot_multi_task_recv_then_send() {
|
||||
let (tx, rx) = channel::<Box<int>>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
});
|
||||
|
||||
@ -1335,10 +1335,10 @@ mod test {
|
||||
#[test]
|
||||
fn oneshot_multi_task_recv_then_close() {
|
||||
let (tx, rx) = channel::<Box<int>>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(tx);
|
||||
});
|
||||
let res = Thread::scoped(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
}).join();
|
||||
assert!(res.is_err());
|
||||
@ -1348,7 +1348,7 @@ mod test {
|
||||
fn oneshot_multi_thread_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(rx);
|
||||
});
|
||||
drop(tx);
|
||||
@ -1359,10 +1359,10 @@ mod test {
|
||||
fn oneshot_multi_thread_send_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(rx);
|
||||
});
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
tx.send(1).unwrap();
|
||||
}).join();
|
||||
}
|
||||
@ -1372,14 +1372,14 @@ mod test {
|
||||
fn oneshot_multi_thread_recv_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = channel::<int>();
|
||||
Thread::spawn(move|| {
|
||||
let res = Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
}).join();
|
||||
assert!(res.is_err());
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(tx);
|
||||
});
|
||||
});
|
||||
@ -1390,7 +1390,7 @@ mod test {
|
||||
fn oneshot_multi_thread_send_recv_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(box 10).unwrap();
|
||||
});
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
@ -1408,7 +1408,7 @@ mod test {
|
||||
fn send(tx: Sender<Box<int>>, i: int) {
|
||||
if i == 10 { return }
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(box i).unwrap();
|
||||
send(tx, i + 1);
|
||||
});
|
||||
@ -1417,7 +1417,7 @@ mod test {
|
||||
fn recv(rx: Receiver<Box<int>>, i: int) {
|
||||
if i == 10 { return }
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box i);
|
||||
recv(rx, i + 1);
|
||||
});
|
||||
@ -1439,7 +1439,7 @@ mod test {
|
||||
let total = stress_factor() + 100;
|
||||
for _ in 0..total {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
}
|
||||
@ -1454,7 +1454,7 @@ mod test {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let (total_tx, total_rx) = channel::<int>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut acc = 0;
|
||||
for x in rx.iter() {
|
||||
acc += x;
|
||||
@ -1474,7 +1474,7 @@ mod test {
|
||||
let (tx, rx) = channel::<int>();
|
||||
let (count_tx, count_rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut count = 0;
|
||||
for x in rx.iter() {
|
||||
if count >= 3 {
|
||||
@ -1499,7 +1499,7 @@ mod test {
|
||||
let (tx1, rx1) = channel::<int>();
|
||||
let (tx2, rx2) = channel::<()>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx2.recv().unwrap();
|
||||
tx1.send(1).unwrap();
|
||||
tx3.send(()).unwrap();
|
||||
@ -1524,13 +1524,13 @@ mod test {
|
||||
fn destroy_upgraded_shared_port_when_sender_still_active() {
|
||||
let (tx, rx) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap(); // wait on a oneshot
|
||||
drop(rx); // destroy a shared
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
// 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
|
||||
let t = tx.clone();
|
||||
@ -1547,7 +1547,7 @@ mod sync_tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use std::env;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use super::*;
|
||||
|
||||
pub fn stress_factor() -> uint {
|
||||
@ -1583,7 +1583,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn smoke_threads() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
assert_eq!(rx.recv().unwrap(), 1);
|
||||
@ -1608,7 +1608,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn port_gone_concurrent() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
while tx.send(1).is_ok() {}
|
||||
@ -1618,7 +1618,7 @@ mod sync_tests {
|
||||
fn port_gone_concurrent_shared() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let tx2 = tx.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
|
||||
@ -1643,7 +1643,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn chan_gone_concurrent() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(1).unwrap();
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
@ -1653,7 +1653,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn stress() {
|
||||
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 {
|
||||
@ -1668,7 +1668,7 @@ mod sync_tests {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let (dtx, drx) = sync_channel::<()>(0);
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
for _ in 0..AMT * NTHREADS {
|
||||
assert_eq!(rx.recv().unwrap(), 1);
|
||||
}
|
||||
@ -1681,7 +1681,7 @@ mod sync_tests {
|
||||
|
||||
for _ in 0..NTHREADS {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
for _ in 0..AMT { tx.send(1).unwrap(); }
|
||||
});
|
||||
}
|
||||
@ -1714,7 +1714,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn oneshot_single_thread_recv_chan_close() {
|
||||
// Receiving on a closed chan will panic
|
||||
let res = Thread::scoped(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
drop(tx);
|
||||
rx.recv().unwrap();
|
||||
@ -1789,7 +1789,7 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn oneshot_multi_task_recv_then_send() {
|
||||
let (tx, rx) = sync_channel::<Box<int>>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
});
|
||||
|
||||
@ -1799,10 +1799,10 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn oneshot_multi_task_recv_then_close() {
|
||||
let (tx, rx) = sync_channel::<Box<int>>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(tx);
|
||||
});
|
||||
let res = Thread::scoped(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
}).join();
|
||||
assert!(res.is_err());
|
||||
@ -1812,7 +1812,7 @@ mod sync_tests {
|
||||
fn oneshot_multi_thread_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(rx);
|
||||
});
|
||||
drop(tx);
|
||||
@ -1823,10 +1823,10 @@ mod sync_tests {
|
||||
fn oneshot_multi_thread_send_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
drop(rx);
|
||||
});
|
||||
let _ = Thread::scoped(move || {
|
||||
let _ = thread::spawn(move || {
|
||||
tx.send(1).unwrap();
|
||||
}).join();
|
||||
}
|
||||
@ -1836,14 +1836,14 @@ mod sync_tests {
|
||||
fn oneshot_multi_thread_recv_close_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let res = Thread::scoped(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let res = thread::spawn(move|| {
|
||||
rx.recv().unwrap();
|
||||
}).join();
|
||||
assert!(res.is_err());
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(tx);
|
||||
});
|
||||
});
|
||||
@ -1854,7 +1854,7 @@ mod sync_tests {
|
||||
fn oneshot_multi_thread_send_recv_stress() {
|
||||
for _ in 0..stress_factor() {
|
||||
let (tx, rx) = sync_channel::<Box<int>>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
tx.send(box 10).unwrap();
|
||||
});
|
||||
assert!(rx.recv().unwrap() == box 10);
|
||||
@ -1872,7 +1872,7 @@ mod sync_tests {
|
||||
fn send(tx: SyncSender<Box<int>>, i: int) {
|
||||
if i == 10 { return }
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(box i).unwrap();
|
||||
send(tx, i + 1);
|
||||
});
|
||||
@ -1881,7 +1881,7 @@ mod sync_tests {
|
||||
fn recv(rx: Receiver<Box<int>>, i: int) {
|
||||
if i == 10 { return }
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
assert!(rx.recv().unwrap() == box i);
|
||||
recv(rx, i + 1);
|
||||
});
|
||||
@ -1903,7 +1903,7 @@ mod sync_tests {
|
||||
let total = stress_factor() + 100;
|
||||
for _ in 0..total {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
}
|
||||
@ -1918,7 +1918,7 @@ mod sync_tests {
|
||||
let (tx, 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;
|
||||
for x in rx.iter() {
|
||||
acc += x;
|
||||
@ -1938,7 +1938,7 @@ mod sync_tests {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let (count_tx, count_rx) = sync_channel(0);
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let mut count = 0;
|
||||
for x in rx.iter() {
|
||||
if count >= 3 {
|
||||
@ -1963,7 +1963,7 @@ mod sync_tests {
|
||||
let (tx1, rx1) = sync_channel::<int>(1);
|
||||
let (tx2, rx2) = sync_channel::<()>(1);
|
||||
let (tx3, rx3) = sync_channel::<()>(1);
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx2.recv().unwrap();
|
||||
tx1.send(1).unwrap();
|
||||
tx3.send(()).unwrap();
|
||||
@ -1988,13 +1988,13 @@ mod sync_tests {
|
||||
fn destroy_upgraded_shared_port_when_sender_still_active() {
|
||||
let (tx, rx) = 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
|
||||
drop(rx); // destroy a shared
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
// 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
|
||||
let t = tx.clone();
|
||||
@ -2008,14 +2008,14 @@ mod sync_tests {
|
||||
#[test]
|
||||
fn send1() {
|
||||
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(()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send2() {
|
||||
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());
|
||||
}
|
||||
|
||||
@ -2023,7 +2023,7 @@ mod sync_tests {
|
||||
fn send3() {
|
||||
let (tx, rx) = sync_channel::<int>(1);
|
||||
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());
|
||||
}
|
||||
|
||||
@ -2033,11 +2033,11 @@ mod sync_tests {
|
||||
let tx2 = tx.clone();
|
||||
let (done, donerx) = channel();
|
||||
let done2 = done.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
assert!(tx.send(1).is_err());
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
assert!(tx2.send(2).is_err());
|
||||
done2.send(()).unwrap();
|
||||
});
|
||||
@ -2073,7 +2073,7 @@ mod sync_tests {
|
||||
let (tx1, rx1) = sync_channel::<()>(3);
|
||||
let (tx2, rx2) = sync_channel::<()>(3);
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx1.recv().unwrap();
|
||||
tx2.try_send(()).unwrap();
|
||||
});
|
||||
|
||||
@ -160,7 +160,7 @@ mod tests {
|
||||
use sync::mpsc::channel;
|
||||
use super::{Queue, Data, Empty, Inconsistent};
|
||||
use sync::Arc;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_full() {
|
||||
@ -184,7 +184,7 @@ mod tests {
|
||||
for _ in 0..nthreads {
|
||||
let tx = tx.clone();
|
||||
let q = q.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
for i in 0..nmsgs {
|
||||
q.push(i);
|
||||
}
|
||||
|
||||
@ -347,7 +347,7 @@ impl Iterator for Packets {
|
||||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use sync::mpsc::*;
|
||||
|
||||
// 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 (tx3, rx3) = channel::<int>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in 0u..20 { Thread::yield_now(); }
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0u..20 { thread::yield_now(); }
|
||||
tx1.send(1).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
for _ in 0u..20 { Thread::yield_now(); }
|
||||
for _ in 0u..20 { thread::yield_now(); }
|
||||
});
|
||||
|
||||
select! {
|
||||
@ -451,8 +451,8 @@ mod test {
|
||||
let (tx2, rx2) = channel::<int>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in 0u..20 { Thread::yield_now(); }
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0u..20 { thread::yield_now(); }
|
||||
tx1.send(1).unwrap();
|
||||
tx2.send(2).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
@ -478,7 +478,7 @@ mod test {
|
||||
let (tx2, rx2) = channel::<int>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for i in 0..AMT {
|
||||
if i % 2 == 0 {
|
||||
tx1.send(i).unwrap();
|
||||
@ -504,7 +504,7 @@ mod test {
|
||||
let (_tx2, rx2) = channel::<int>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx3.recv().unwrap();
|
||||
tx1.clone();
|
||||
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
|
||||
@ -526,7 +526,7 @@ mod test {
|
||||
let (_tx2, rx2) = channel::<int>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
rx3.recv().unwrap();
|
||||
tx1.clone();
|
||||
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
|
||||
@ -547,7 +547,7 @@ mod test {
|
||||
let (tx1, rx1) = channel::<()>();
|
||||
let (tx2, rx2) = channel::<()>();
|
||||
let (tx3, rx3) = channel::<()>();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let s = Select::new();
|
||||
let mut h1 = s.handle(&rx1);
|
||||
let mut h2 = s.handle(&rx2);
|
||||
@ -557,7 +557,7 @@ mod test {
|
||||
tx3.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in 0u..1000 { Thread::yield_now(); }
|
||||
for _ in 0u..1000 { thread::yield_now(); }
|
||||
drop(tx1.clone());
|
||||
tx2.send(()).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
@ -663,14 +663,14 @@ mod test {
|
||||
fn oneshot_data_waiting() {
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
select! {
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in 0u..100 { Thread::yield_now() }
|
||||
for _ in 0u..100 { thread::yield_now() }
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
@ -683,14 +683,14 @@ mod test {
|
||||
tx1.send(()).unwrap();
|
||||
rx1.recv().unwrap();
|
||||
rx1.recv().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
select! {
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in 0u..100 { Thread::yield_now() }
|
||||
for _ in 0u..100 { thread::yield_now() }
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
@ -702,14 +702,14 @@ mod test {
|
||||
drop(tx1.clone());
|
||||
tx1.send(()).unwrap();
|
||||
rx1.recv().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
select! {
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in 0u..100 { Thread::yield_now() }
|
||||
for _ in 0u..100 { thread::yield_now() }
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
@ -726,8 +726,8 @@ mod test {
|
||||
#[test]
|
||||
fn sync2() {
|
||||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in 0u..100 { Thread::yield_now() }
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0u..100 { thread::yield_now() }
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
select! {
|
||||
@ -739,8 +739,8 @@ mod test {
|
||||
fn sync3() {
|
||||
let (tx1, rx1) = sync_channel::<int>(0);
|
||||
let (tx2, rx2): (Sender<int>, Receiver<int>) = channel();
|
||||
let _t = Thread::spawn(move|| { tx1.send(1).unwrap(); });
|
||||
let _t = Thread::spawn(move|| { tx2.send(2).unwrap(); });
|
||||
let _t = thread::spawn(move|| { tx1.send(1).unwrap(); });
|
||||
let _t = thread::spawn(move|| { tx2.send(2).unwrap(); });
|
||||
select! {
|
||||
n = rx1.recv() => {
|
||||
let n = n.unwrap();
|
||||
|
||||
@ -31,7 +31,7 @@ use sync::mpsc::mpsc_queue as mpsc;
|
||||
use sync::mpsc::select::StartResult::*;
|
||||
use sync::mpsc::select::StartResult;
|
||||
use sync::{Mutex, MutexGuard};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
const DISCONNECTED: isize = isize::MIN;
|
||||
const FUDGE: isize = 1024;
|
||||
@ -194,7 +194,7 @@ impl<T: Send> Packet<T> {
|
||||
match self.queue.pop() {
|
||||
mpsc::Data(..) => {}
|
||||
mpsc::Empty => break,
|
||||
mpsc::Inconsistent => Thread::yield_now(),
|
||||
mpsc::Inconsistent => thread::yield_now(),
|
||||
}
|
||||
}
|
||||
// maybe we're done, if we're not the last ones
|
||||
@ -283,7 +283,7 @@ impl<T: Send> Packet<T> {
|
||||
mpsc::Inconsistent => {
|
||||
let data;
|
||||
loop {
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
match self.queue.pop() {
|
||||
mpsc::Data(t) => { data = t; break }
|
||||
mpsc::Empty => panic!("inconsistent => empty"),
|
||||
@ -460,7 +460,7 @@ impl<T: Send> Packet<T> {
|
||||
drop(self.take_to_wake());
|
||||
} else {
|
||||
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
|
||||
|
||||
@ -246,7 +246,7 @@ mod test {
|
||||
|
||||
use sync::Arc;
|
||||
use super::Queue;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use sync::mpsc::channel;
|
||||
|
||||
#[test]
|
||||
@ -324,7 +324,7 @@ mod test {
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let q2 = q.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
for _ in 0u..100000 {
|
||||
loop {
|
||||
match q2.pop() {
|
||||
|
||||
@ -26,7 +26,7 @@ use core::prelude::*;
|
||||
|
||||
use core::cmp;
|
||||
use core::isize;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
use sync::atomic::{AtomicIsize, AtomicUsize, Ordering, AtomicBool};
|
||||
use sync::mpsc::Receiver;
|
||||
@ -440,7 +440,7 @@ impl<T: Send> Packet<T> {
|
||||
drop(self.take_to_wake());
|
||||
} else {
|
||||
while self.to_wake.load(Ordering::SeqCst) != 0 {
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
}
|
||||
}
|
||||
assert_eq!(self.steals, 0);
|
||||
|
||||
@ -47,7 +47,7 @@ use sys_common::mutex as sys;
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::sync::{Arc, Mutex};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
/// use std::sync::mpsc::channel;
|
||||
///
|
||||
/// const N: uint = 10;
|
||||
@ -62,7 +62,7 @@ use sys_common::mutex as sys;
|
||||
/// let (tx, rx) = channel();
|
||||
/// for _ in 0u..10 {
|
||||
/// 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.
|
||||
/// // Our non-atomic increment is safe because we're the only thread
|
||||
/// // which can access the shared state when the lock is held.
|
||||
@ -85,12 +85,12 @@ use sys_common::mutex as sys;
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::sync::{Arc, Mutex};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// let lock = Arc::new(Mutex::new(0u));
|
||||
/// let lock2 = lock.clone();
|
||||
///
|
||||
/// let _ = Thread::scoped(move || -> () {
|
||||
/// let _ = thread::spawn(move || -> () {
|
||||
/// // This thread will acquire the mutex first, unwrapping the result of
|
||||
/// // `lock` because the lock has not been poisoned.
|
||||
/// let _lock = lock2.lock().unwrap();
|
||||
@ -350,7 +350,7 @@ mod test {
|
||||
|
||||
use sync::mpsc::channel;
|
||||
use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
|
||||
|
||||
@ -393,9 +393,9 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
for _ in 0..K {
|
||||
let tx2 = tx.clone();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
|
||||
thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
|
||||
let tx2 = tx.clone();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
|
||||
thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
|
||||
}
|
||||
|
||||
drop(tx);
|
||||
@ -419,7 +419,7 @@ mod test {
|
||||
let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
|
||||
let packet2 = Packet(packet.0.clone());
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
// wait until parent gets in
|
||||
rx.recv().unwrap();
|
||||
let &(ref lock, ref cvar) = &*packet2.0;
|
||||
@ -443,7 +443,7 @@ mod test {
|
||||
let packet2 = Packet(packet.0.clone());
|
||||
let (tx, rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move || -> () {
|
||||
let _t = thread::spawn(move || -> () {
|
||||
rx.recv().unwrap();
|
||||
let &(ref lock, ref cvar) = &*packet2.0;
|
||||
let _g = lock.lock().unwrap();
|
||||
@ -471,7 +471,7 @@ mod test {
|
||||
let arc = Arc::new(Mutex::new(1));
|
||||
assert!(!arc.is_poisoned());
|
||||
let arc2 = arc.clone();
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
let lock = arc2.lock().unwrap();
|
||||
assert_eq!(*lock, 2);
|
||||
}).join();
|
||||
@ -486,7 +486,7 @@ mod test {
|
||||
let arc = Arc::new(Mutex::new(1));
|
||||
let arc2 = Arc::new(Mutex::new(arc));
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let lock = arc2.lock().unwrap();
|
||||
let lock2 = lock.lock().unwrap();
|
||||
assert_eq!(*lock2, 1);
|
||||
@ -499,7 +499,7 @@ mod test {
|
||||
fn test_mutex_arc_access_in_unwind() {
|
||||
let arc = Arc::new(Mutex::new(1));
|
||||
let arc2 = arc.clone();
|
||||
let _ = Thread::scoped(move|| -> () {
|
||||
let _ = thread::spawn(move|| -> () {
|
||||
struct Unwinder {
|
||||
i: Arc<Mutex<int>>,
|
||||
}
|
||||
|
||||
@ -127,7 +127,7 @@ impl Once {
|
||||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use super::{ONCE_INIT, Once};
|
||||
use sync::mpsc::channel;
|
||||
|
||||
@ -149,8 +149,8 @@ mod test {
|
||||
let (tx, rx) = channel();
|
||||
for _ in 0u..10 {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
for _ in 0u..4 { Thread::yield_now() }
|
||||
thread::spawn(move|| {
|
||||
for _ in 0u..4 { thread::yield_now() }
|
||||
unsafe {
|
||||
O.call_once(|| {
|
||||
assert!(!run);
|
||||
|
||||
@ -13,7 +13,7 @@ use prelude::v1::*;
|
||||
use cell::UnsafeCell;
|
||||
use error::{Error, FromError};
|
||||
use fmt;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
pub struct Flag { failed: UnsafeCell<bool> }
|
||||
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 {
|
||||
#[inline]
|
||||
pub fn borrow(&self) -> LockResult<Guard> {
|
||||
let ret = Guard { panicking: Thread::panicking() };
|
||||
let ret = Guard { panicking: thread::panicking() };
|
||||
if unsafe { *self.failed.get() } {
|
||||
Err(PoisonError::new(ret))
|
||||
} else {
|
||||
@ -31,7 +31,7 @@ impl Flag {
|
||||
|
||||
#[inline]
|
||||
pub fn done(&self, guard: &Guard) {
|
||||
if !guard.panicking && Thread::panicking() {
|
||||
if !guard.panicking && thread::panicking() {
|
||||
unsafe { *self.failed.get() = true; }
|
||||
}
|
||||
}
|
||||
|
||||
@ -400,7 +400,7 @@ mod tests {
|
||||
|
||||
use rand::{self, Rng};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use sync::{Arc, RwLock, StaticRwLock, RW_LOCK_INIT};
|
||||
|
||||
#[test]
|
||||
@ -431,7 +431,7 @@ mod tests {
|
||||
let (tx, rx) = channel::<()>();
|
||||
for _ in 0..N {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut rng = rand::thread_rng();
|
||||
for _ in 0..M {
|
||||
if rng.gen_weighted_bool(N) {
|
||||
@ -452,7 +452,7 @@ mod tests {
|
||||
fn test_rw_arc_poison_wr() {
|
||||
let arc = Arc::new(RwLock::new(1));
|
||||
let arc2 = arc.clone();
|
||||
let _: Result<uint, _> = Thread::scoped(move|| {
|
||||
let _: Result<uint, _> = thread::spawn(move|| {
|
||||
let _lock = arc2.write().unwrap();
|
||||
panic!();
|
||||
}).join();
|
||||
@ -464,7 +464,7 @@ mod tests {
|
||||
let arc = Arc::new(RwLock::new(1));
|
||||
assert!(!arc.is_poisoned());
|
||||
let arc2 = arc.clone();
|
||||
let _: Result<uint, _> = Thread::scoped(move|| {
|
||||
let _: Result<uint, _> = thread::spawn(move|| {
|
||||
let _lock = arc2.write().unwrap();
|
||||
panic!();
|
||||
}).join();
|
||||
@ -476,7 +476,7 @@ mod tests {
|
||||
fn test_rw_arc_no_poison_rr() {
|
||||
let arc = Arc::new(RwLock::new(1));
|
||||
let arc2 = arc.clone();
|
||||
let _: Result<uint, _> = Thread::scoped(move|| {
|
||||
let _: Result<uint, _> = thread::spawn(move|| {
|
||||
let _lock = arc2.read().unwrap();
|
||||
panic!();
|
||||
}).join();
|
||||
@ -487,7 +487,7 @@ mod tests {
|
||||
fn test_rw_arc_no_poison_rw() {
|
||||
let arc = Arc::new(RwLock::new(1));
|
||||
let arc2 = arc.clone();
|
||||
let _: Result<uint, _> = Thread::scoped(move|| {
|
||||
let _: Result<uint, _> = thread::spawn(move|| {
|
||||
let _lock = arc2.read().unwrap();
|
||||
panic!()
|
||||
}).join();
|
||||
@ -501,12 +501,12 @@ mod tests {
|
||||
let arc2 = arc.clone();
|
||||
let (tx, rx) = channel();
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut lock = arc2.write().unwrap();
|
||||
for _ in 0u..10 {
|
||||
let tmp = *lock;
|
||||
*lock = -1;
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
*lock = tmp + 1;
|
||||
}
|
||||
tx.send(()).unwrap();
|
||||
@ -516,7 +516,7 @@ mod tests {
|
||||
let mut children = Vec::new();
|
||||
for _ in 0u..5 {
|
||||
let arc3 = arc.clone();
|
||||
children.push(Thread::scoped(move|| {
|
||||
children.push(thread::spawn(move|| {
|
||||
let lock = arc3.read().unwrap();
|
||||
assert!(*lock >= 0);
|
||||
}));
|
||||
@ -537,7 +537,7 @@ mod tests {
|
||||
fn test_rw_arc_access_in_unwind() {
|
||||
let arc = Arc::new(RwLock::new(1));
|
||||
let arc2 = arc.clone();
|
||||
let _ = Thread::scoped(move|| -> () {
|
||||
let _ = thread::spawn(move|| -> () {
|
||||
struct Unwinder {
|
||||
i: Arc<RwLock<int>>,
|
||||
}
|
||||
|
||||
@ -114,7 +114,7 @@ mod tests {
|
||||
use sync::Arc;
|
||||
use super::Semaphore;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
#[test]
|
||||
fn test_sem_acquire_release() {
|
||||
@ -134,7 +134,7 @@ mod tests {
|
||||
fn test_sem_as_mutex() {
|
||||
let s = Arc::new(Semaphore::new(1));
|
||||
let s2 = s.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _g = s2.access();
|
||||
});
|
||||
let _g = s.access();
|
||||
@ -146,7 +146,7 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let s = Arc::new(Semaphore::new(0));
|
||||
let s2 = s.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
s2.acquire();
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
@ -157,7 +157,7 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
let s = Arc::new(Semaphore::new(0));
|
||||
let s2 = s.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
s2.release();
|
||||
let _ = rx.recv();
|
||||
});
|
||||
@ -173,7 +173,7 @@ mod tests {
|
||||
let s2 = s.clone();
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _g = s2.access();
|
||||
let _ = rx2.recv();
|
||||
tx1.send(()).unwrap();
|
||||
@ -190,7 +190,7 @@ mod tests {
|
||||
let (tx, rx) = channel();
|
||||
{
|
||||
let _g = s.access();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(()).unwrap();
|
||||
drop(s2.access());
|
||||
tx.send(()).unwrap();
|
||||
|
||||
@ -20,7 +20,7 @@ use core::prelude::*;
|
||||
|
||||
use sync::{Arc, Mutex};
|
||||
use sync::mpsc::{channel, Sender, Receiver};
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
use thunk::Thunk;
|
||||
|
||||
struct Sentinel<'a> {
|
||||
@ -112,7 +112,7 @@ impl TaskPool {
|
||||
}
|
||||
|
||||
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.
|
||||
let sentinel = Sentinel::new(&jobs);
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ use sync::{StaticMutex, StaticCondvar};
|
||||
use sync::mpsc::{channel, Sender, Receiver};
|
||||
use sys::helper_signal;
|
||||
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
/// A structure for management of a helper thread.
|
||||
///
|
||||
@ -95,7 +95,7 @@ impl<M: Send> Helper<M> {
|
||||
let receive = RaceBox(receive);
|
||||
|
||||
let t = f();
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
helper(receive.0, rx, t);
|
||||
let _g = self.lock.lock().unwrap();
|
||||
*self.shutdown.get() = true;
|
||||
|
||||
@ -29,7 +29,7 @@ thread_local! { static THREAD_INFO: RefCell<Option<ThreadInfo>> = RefCell::new(N
|
||||
impl ThreadInfo {
|
||||
fn with<R, F>(f: F) -> R where F: FnOnce(&mut ThreadInfo) -> R {
|
||||
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");
|
||||
}
|
||||
|
||||
@ -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 {
|
||||
fn new(name: Option<String>) -> Self;
|
||||
}
|
||||
|
||||
@ -24,7 +24,7 @@
|
||||
//! # Usage
|
||||
//!
|
||||
//! 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
|
||||
//! unsafe code to interoperate with.
|
||||
//!
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
|
||||
use core::prelude::*;
|
||||
|
||||
use io;
|
||||
use boxed::Box;
|
||||
use cmp;
|
||||
use mem;
|
||||
@ -191,7 +192,7 @@ pub mod guard {
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn create(stack: uint, p: Thunk) -> rust_thread {
|
||||
pub unsafe fn create(stack: uint, p: Thunk) -> io::Result<rust_thread> {
|
||||
let mut native: libc::pthread_t = mem::zeroed();
|
||||
let mut attr: libc::pthread_attr_t = mem::zeroed();
|
||||
assert_eq!(pthread_attr_init(&mut attr), 0);
|
||||
@ -226,9 +227,10 @@ pub unsafe fn create(stack: uint, p: Thunk) -> rust_thread {
|
||||
if ret != 0 {
|
||||
// be sure to not leak the closure
|
||||
let _p: Box<Box<FnOnce()+Send>> = mem::transmute(arg);
|
||||
panic!("failed to spawn native thread: {}", ret);
|
||||
Err(io::Error::from_os_error(ret))
|
||||
} else {
|
||||
Ok(native)
|
||||
}
|
||||
native
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "android"))]
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
|
||||
use boxed::Box;
|
||||
use cmp;
|
||||
use io;
|
||||
use mem;
|
||||
use ptr;
|
||||
use libc;
|
||||
@ -42,7 +43,7 @@ pub mod guard {
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn create(stack: uint, p: Thunk) -> rust_thread {
|
||||
pub unsafe fn create(stack: uint, p: Thunk) -> io::Result<rust_thread> {
|
||||
let arg: *mut libc::c_void = mem::transmute(box p);
|
||||
// FIXME On UNIX, we guard against stack sizes that are too small but
|
||||
// that's because pthreads enforces that stacks are at least
|
||||
@ -60,9 +61,10 @@ pub unsafe fn create(stack: uint, p: Thunk) -> rust_thread {
|
||||
if ret as uint == 0 {
|
||||
// be sure to not leak the closure
|
||||
let _p: Box<Thunk> = mem::transmute(arg);
|
||||
panic!("failed to spawn native thread: {:?}", ret);
|
||||
Err(io::Error::last_os_error())
|
||||
} else {
|
||||
Ok(ret)
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
pub unsafe fn set_name(_name: &str) {
|
||||
|
||||
@ -42,32 +42,32 @@
|
||||
//! Already-running threads are represented via the `Thread` type, which you can
|
||||
//! get in one of two ways:
|
||||
//!
|
||||
//! * By spawning a new thread, e.g. using the `Thread::spawn` constructor;
|
||||
//! * By requesting the current thread, using the `Thread::current` function.
|
||||
//! * By spawning a new thread, e.g. using the `thread::spawn` constructor;
|
||||
//! * By requesting the current thread, using the `thread::current` function.
|
||||
//!
|
||||
//! Threads can be named, and provide some built-in support for low-level
|
||||
//! 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.
|
||||
//!
|
||||
//! ## 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
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! let thread = Thread::spawn(move || {
|
||||
//! thread::spawn(move || {
|
||||
//! println!("Hello, World!");
|
||||
//! // some computation here
|
||||
//! });
|
||||
//! ```
|
||||
//!
|
||||
//! The spawned thread is "detached" from the current thread, meaning that it
|
||||
//! can outlive the thread that spawned it. (Note, however, that when the main
|
||||
//! thread terminates all detached threads are terminated as well.) The returned
|
||||
//! `Thread` handle can be used for low-level synchronization as described below.
|
||||
//! In this example, the spawned thread is "detached" from the current
|
||||
//! thread, meaning that it can outlive the thread that spawned
|
||||
//! it. (Note, however, that when the main thread terminates all
|
||||
//! detached threads are terminated as well.)
|
||||
//!
|
||||
//! ## Scoped threads
|
||||
//!
|
||||
@ -76,23 +76,23 @@
|
||||
//! For this scenario, use the `scoped` constructor:
|
||||
//!
|
||||
//! ```rust
|
||||
//! use std::thread::Thread;
|
||||
//! use std::thread;
|
||||
//!
|
||||
//! let guard = Thread::scoped(move || {
|
||||
//! let guard = thread::scoped(move || {
|
||||
//! println!("Hello, World!");
|
||||
//! // some computation here
|
||||
//! });
|
||||
//! // 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, it
|
||||
//! returns a *join guard* from which a `Thread` can be extracted. The join
|
||||
//! guard is an RAII-style guard that will automatically join the child thread
|
||||
//! (block until it terminates) when it is dropped. You can join the child
|
||||
//! thread in advance by calling the `join` method on the guard, which will also
|
||||
//! return the result produced by the thread. A handle to the thread itself is
|
||||
//! available via the `thread` method on the join guard.
|
||||
//! The `scoped` function doesn't return a `Thread` directly; instead,
|
||||
//! it returns a *join guard*. The join guard is an RAII-style guard
|
||||
//! that will automatically join the child thread (block until it
|
||||
//! terminates) when it is dropped. You can join the child thread in
|
||||
//! advance by calling the `join` method on the guard, which will also
|
||||
//! return the result produced by the thread. A handle to the thread
|
||||
//! itself is available via the `thread` method on the join guard.
|
||||
//!
|
||||
//! (Note: eventually, the `scoped` constructor will allow the parent and child
|
||||
//! threads to data that lives on the parent thread's stack, but some language
|
||||
@ -120,10 +120,10 @@
|
||||
//! Conceptually, each `Thread` handle has an associated token, which is
|
||||
//! 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
|
||||
//! 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.
|
||||
//!
|
||||
//! * The `unpark()` method on a `Thread` atomically makes the token available
|
||||
@ -151,6 +151,8 @@ use any::Any;
|
||||
use boxed::Box;
|
||||
use cell::UnsafeCell;
|
||||
use clone::Clone;
|
||||
use fmt;
|
||||
use io;
|
||||
use marker::{Send, Sync};
|
||||
use ops::{Drop, FnOnce};
|
||||
use option::Option::{self, Some, None};
|
||||
@ -224,49 +226,58 @@ impl Builder {
|
||||
self
|
||||
}
|
||||
|
||||
/// Spawn a new detached thread, and return a handle to it.
|
||||
/// Spawn a new thread, and return a join handle for it.
|
||||
///
|
||||
/// See `Thead::spawn` and the module doc for more details.
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "may change with specifics of new Send semantics")]
|
||||
pub fn spawn<F>(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static {
|
||||
let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {}));
|
||||
unsafe { imp::detach(native) };
|
||||
thread
|
||||
/// The child thread may outlive the parent (unless the parent thread
|
||||
/// is the main thread; the whole process is terminated when the main
|
||||
/// thread finishes.) The join handle can be used to block on
|
||||
/// termination of the child thread, including recovering its panics.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Unlike the `spawn` free function, this method yields an
|
||||
/// `io::Result` to capture any failure to create the thread at
|
||||
/// the OS level.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn spawn<F>(self, f: F) -> io::Result<JoinHandle> where
|
||||
F: FnOnce(), F: Send + 'static
|
||||
{
|
||||
self.spawn_inner(Thunk::new(f)).map(|i| JoinHandle(i))
|
||||
}
|
||||
|
||||
/// Spawn a new child thread that must be joined within a given
|
||||
/// scope, and return a `JoinGuard`.
|
||||
///
|
||||
/// See `Thead::scoped` and the module doc for more details.
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "may change with specifics of new Send semantics")]
|
||||
pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where
|
||||
/// The join guard can be used to explicitly join the child thread (via
|
||||
/// `join`), returning `Result<T>`, or it will implicitly join the child
|
||||
/// upon being dropped. Because the child thread may refer to data on the
|
||||
/// current thread's stack (hence the "scoped" name), it cannot be detached;
|
||||
/// it *must* be joined before the relevant stack frame is popped. See the
|
||||
/// module documentation for additional details.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Unlike the `scoped` free function, this method yields an
|
||||
/// `io::Result` to capture any failure to create the thread at
|
||||
/// the OS level.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn scoped<'a, T, F>(self, f: F) -> io::Result<JoinGuard<'a, T>> where
|
||||
T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
|
||||
{
|
||||
let my_packet = Packet(Arc::new(UnsafeCell::new(None)));
|
||||
let their_packet = Packet(my_packet.0.clone());
|
||||
let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(move |ret| unsafe {
|
||||
*their_packet.0.get() = Some(ret);
|
||||
}));
|
||||
|
||||
JoinGuard {
|
||||
native: native,
|
||||
joined: false,
|
||||
packet: my_packet,
|
||||
thread: thread,
|
||||
}
|
||||
self.spawn_inner(Thunk::new(f)).map(JoinGuard)
|
||||
}
|
||||
|
||||
fn spawn_inner<T: Send>(self, f: Thunk<(), T>, finish: Thunk<Result<T>, ()>)
|
||||
-> (imp::rust_thread, Thread)
|
||||
{
|
||||
fn spawn_inner<T: Send>(self, f: Thunk<(), T>) -> io::Result<JoinInner<T>> {
|
||||
let Builder { name, stack_size, stdout, stderr } = self;
|
||||
|
||||
let stack_size = stack_size.unwrap_or(rt::min_stack());
|
||||
|
||||
let my_thread = Thread::new(name);
|
||||
let their_thread = my_thread.clone();
|
||||
|
||||
let my_packet = Packet(Arc::new(UnsafeCell::new(None)));
|
||||
let their_packet = Packet(my_packet.0.clone());
|
||||
|
||||
// Spawning a new OS thread guarantees that __morestack will never get
|
||||
// triggered, but we must manually set up the actual stack bounds once
|
||||
// this function starts executing. This raises the lower limit by a bit
|
||||
@ -316,17 +327,120 @@ impl Builder {
|
||||
unwind::try(move || *ptr = Some(f.invoke(())))
|
||||
}
|
||||
};
|
||||
finish.invoke(match (output, try_result) {
|
||||
(Some(data), Ok(_)) => Ok(data),
|
||||
(None, Err(cause)) => Err(cause),
|
||||
_ => unreachable!()
|
||||
});
|
||||
unsafe {
|
||||
*their_packet.0.get() = Some(match (output, try_result) {
|
||||
(Some(data), Ok(_)) => Ok(data),
|
||||
(None, Err(cause)) => Err(cause),
|
||||
_ => unreachable!()
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
(unsafe { imp::create(stack_size, Thunk::new(main)) }, my_thread)
|
||||
Ok(JoinInner {
|
||||
native: try!(unsafe { imp::create(stack_size, Thunk::new(main)) }),
|
||||
thread: my_thread,
|
||||
packet: my_packet,
|
||||
joined: false,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Spawn a new, returning a join handle for it.
|
||||
///
|
||||
/// The child thread may outlive the parent (unless the parent thread
|
||||
/// is the main thread; the whole process is terminated when the main
|
||||
/// thread finishes.) The join handle can be used to block on
|
||||
/// termination of the child thread, including recovering its panics.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panicks if the OS fails to create a thread; use `Builder::spawn`
|
||||
/// to recover from such errors.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn spawn<F>(f: F) -> JoinHandle where F: FnOnce(), F: Send + 'static {
|
||||
Builder::new().spawn(f).unwrap()
|
||||
}
|
||||
|
||||
/// Spawn a new *scoped* thread, returning a `JoinGuard` for it.
|
||||
///
|
||||
/// The join guard can be used to explicitly join the child thread (via
|
||||
/// `join`), returning `Result<T>`, or it will implicitly join the child
|
||||
/// upon being dropped. Because the child thread may refer to data on the
|
||||
/// current thread's stack (hence the "scoped" name), it cannot be detached;
|
||||
/// it *must* be joined before the relevant stack frame is popped. See the
|
||||
/// module documentation for additional details.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panicks if the OS fails to create a thread; use `Builder::scoped`
|
||||
/// to recover from such errors.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where
|
||||
T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
|
||||
{
|
||||
Builder::new().scoped(f).unwrap()
|
||||
}
|
||||
|
||||
/// Gets a handle to the thread that invokes it.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn current() -> Thread {
|
||||
thread_info::current_thread()
|
||||
}
|
||||
|
||||
/// Cooperatively give up a timeslice to the OS scheduler.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn yield_now() {
|
||||
unsafe { imp::yield_now() }
|
||||
}
|
||||
|
||||
/// Determines whether the current thread is unwinding because of panic.
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn panicking() -> bool {
|
||||
unwind::panicking()
|
||||
}
|
||||
|
||||
/// Block unless or until the current thread's token is made available (may wake spuriously).
|
||||
///
|
||||
/// See the module doc for more detail.
|
||||
//
|
||||
// The implementation currently uses the trivial strategy of a Mutex+Condvar
|
||||
// with wakeup flag, which does not actually allow spurious wakeups. In the
|
||||
// future, this will be implemented in a more efficient way, perhaps along the lines of
|
||||
// http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp
|
||||
// or futuxes, and in either case may allow spurious wakeups.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn park() {
|
||||
let thread = current();
|
||||
let mut guard = thread.inner.lock.lock().unwrap();
|
||||
while !*guard {
|
||||
guard = thread.inner.cvar.wait(guard).unwrap();
|
||||
}
|
||||
*guard = false;
|
||||
}
|
||||
|
||||
/// Block unless or until the current thread's token is made available or
|
||||
/// the specified duration has been reached (may wake spuriously).
|
||||
///
|
||||
/// The semantics of this function are equivalent to `park()` except that the
|
||||
/// thread will be blocked for roughly no longer than dur. This method
|
||||
/// should not be used for precise timing due to anomalies such as
|
||||
/// preemption or platform differences that may not cause the maximum
|
||||
/// amount of time waited to be precisely dur
|
||||
///
|
||||
/// See the module doc for more detail.
|
||||
#[unstable(feature = "std_misc", reason = "recently introduced, depends on Duration")]
|
||||
pub fn park_timeout(dur: Duration) {
|
||||
let thread = current();
|
||||
let mut guard = thread.inner.lock.lock().unwrap();
|
||||
if !*guard {
|
||||
let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap();
|
||||
guard = g;
|
||||
}
|
||||
*guard = false;
|
||||
}
|
||||
|
||||
/// The internal representation of a `Thread` handle
|
||||
struct Inner {
|
||||
name: Option<String>,
|
||||
lock: Mutex<bool>, // true when there is a buffered unpark
|
||||
@ -354,65 +468,51 @@ impl Thread {
|
||||
}
|
||||
}
|
||||
|
||||
/// Spawn a new detached thread, returning a handle to it.
|
||||
///
|
||||
/// The child thread may outlive the parent (unless the parent thread is the
|
||||
/// main thread; the whole process is terminated when the main thread
|
||||
/// finishes.) The thread handle can be used for low-level
|
||||
/// synchronization. See the module documentation for additional details.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "may change with specifics of new Send semantics")]
|
||||
pub fn spawn<F>(f: F) -> Thread where F: FnOnce(), F: Send + 'static {
|
||||
Builder::new().spawn(f)
|
||||
Builder::new().spawn(f).unwrap().thread().clone()
|
||||
}
|
||||
|
||||
/// Spawn a new *scoped* thread, returning a `JoinGuard` for it.
|
||||
///
|
||||
/// The join guard can be used to explicitly join the child thread (via
|
||||
/// `join`), returning `Result<T>`, or it will implicitly join the child
|
||||
/// upon being dropped. Because the child thread may refer to data on the
|
||||
/// current thread's stack (hence the "scoped" name), it cannot be detached;
|
||||
/// it *must* be joined before the relevant stack frame is popped. See the
|
||||
/// module documentation for additional details.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "may change with specifics of new Send semantics")]
|
||||
pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where
|
||||
T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
|
||||
{
|
||||
Builder::new().scoped(f)
|
||||
Builder::new().scoped(f).unwrap()
|
||||
}
|
||||
|
||||
/// Gets a handle to the thread that invokes it.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn current() -> Thread {
|
||||
thread_info::current_thread()
|
||||
}
|
||||
|
||||
/// Cooperatively give up a timeslice to the OS scheduler.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[unstable(feature = "std_misc", reason = "name may change")]
|
||||
pub fn yield_now() {
|
||||
unsafe { imp::yield_now() }
|
||||
}
|
||||
|
||||
/// Determines whether the current thread is unwinding because of panic.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn panicking() -> bool {
|
||||
unwind::panicking()
|
||||
}
|
||||
|
||||
/// Block unless or until the current thread's token is made available (may wake spuriously).
|
||||
///
|
||||
/// See the module doc for more detail.
|
||||
//
|
||||
// The implementation currently uses the trivial strategy of a Mutex+Condvar
|
||||
// with wakeup flag, which does not actually allow spurious wakeups. In the
|
||||
// future, this will be implemented in a more efficient way, perhaps along the lines of
|
||||
// http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp
|
||||
// or futuxes, and in either case may allow spurious wakeups.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[unstable(feature = "std_misc", reason = "recently introduced")]
|
||||
pub fn park() {
|
||||
let thread = Thread::current();
|
||||
let thread = current();
|
||||
let mut guard = thread.inner.lock.lock().unwrap();
|
||||
while !*guard {
|
||||
guard = thread.inner.cvar.wait(guard).unwrap();
|
||||
@ -420,19 +520,11 @@ impl Thread {
|
||||
*guard = false;
|
||||
}
|
||||
|
||||
/// Block unless or until the current thread's token is made available or
|
||||
/// the specified duration has been reached (may wake spuriously).
|
||||
///
|
||||
/// The semantics of this function are equivalent to `park()` except that the
|
||||
/// thread will be blocked for roughly no longer than dur. This method
|
||||
/// should not be used for precise timing due to anomalies such as
|
||||
/// preemption or platform differences that may not cause the maximum
|
||||
/// amount of time waited to be precisely dur
|
||||
///
|
||||
/// See the module doc for more detail.
|
||||
/// Deprecated: use module-level free fucntion.
|
||||
#[deprecated(since = "1.0.0", reason = "use module-level free fucntion")]
|
||||
#[unstable(feature = "std_misc", reason = "recently introduced")]
|
||||
pub fn park_timeout(dur: Duration) {
|
||||
let thread = Thread::current();
|
||||
let thread = current();
|
||||
let mut guard = thread.inner.lock.lock().unwrap();
|
||||
if !*guard {
|
||||
let (g, _) = thread.inner.cvar.wait_timeout(guard, dur).unwrap();
|
||||
@ -444,7 +536,7 @@ impl Thread {
|
||||
/// Atomically makes the handle's token available if it is not already.
|
||||
///
|
||||
/// See the module doc for more detail.
|
||||
#[unstable(feature = "std_misc", reason = "recently introduced")]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn unpark(&self) {
|
||||
let mut guard = self.inner.lock.lock().unwrap();
|
||||
if !*guard {
|
||||
@ -460,6 +552,13 @@ impl Thread {
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl fmt::Debug for Thread {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::Debug::fmt(&self.name(), f)
|
||||
}
|
||||
}
|
||||
|
||||
// a hack to get around privacy restrictions
|
||||
impl thread_info::NewThread for Thread {
|
||||
fn new(name: Option<String>) -> Thread { Thread::new(name) }
|
||||
@ -476,36 +575,16 @@ struct Packet<T>(Arc<UnsafeCell<Option<Result<T>>>>);
|
||||
unsafe impl<T:'static+Send> Send for Packet<T> {}
|
||||
unsafe impl<T> Sync for Packet<T> {}
|
||||
|
||||
/// An RAII-style guard that will block until thread termination when dropped.
|
||||
///
|
||||
/// The type `T` is the return type for the thread's main function.
|
||||
#[must_use]
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "may change with specifics of new Send semantics")]
|
||||
pub struct JoinGuard<'a, T: 'a> {
|
||||
/// Inner representation for JoinHandle and JoinGuard
|
||||
struct JoinInner<T> {
|
||||
native: imp::rust_thread,
|
||||
thread: Thread,
|
||||
joined: bool,
|
||||
packet: Packet<T>,
|
||||
joined: bool,
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
unsafe impl<'a, T: Send + 'a> Sync for JoinGuard<'a, T> {}
|
||||
|
||||
impl<'a, T: Send + 'a> JoinGuard<'a, T> {
|
||||
/// Extract a handle to the thread this guard will join on.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn thread(&self) -> &Thread {
|
||||
&self.thread
|
||||
}
|
||||
|
||||
/// Wait for the associated thread to finish, returning the result of the thread's
|
||||
/// calculation.
|
||||
///
|
||||
/// If the child thread panics, `Err` is returned with the parameter given
|
||||
/// to `panic`.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn join(mut self) -> Result<T> {
|
||||
impl<T> JoinInner<T> {
|
||||
fn join(&mut self) -> Result<T> {
|
||||
assert!(!self.joined);
|
||||
unsafe { imp::join(self.native) };
|
||||
self.joined = true;
|
||||
@ -515,13 +594,90 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// An owned permission to join on a thread (block on its termination).
|
||||
///
|
||||
/// Unlike a `JoinGuard`, a `JoinHandle` *detaches* the child thread
|
||||
/// when it is dropped, rather than automatically joining on drop.
|
||||
///
|
||||
/// Due to platform restrictions, it is not possible to `Clone` this
|
||||
/// handle: the ability to join a child thread is a uniquely-owned
|
||||
/// permission.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct JoinHandle(JoinInner<()>);
|
||||
|
||||
impl JoinHandle {
|
||||
/// Extract a handle to the underlying thread
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn thread(&self) -> &Thread {
|
||||
&self.0.thread
|
||||
}
|
||||
|
||||
/// Wait for the associated thread to finish.
|
||||
///
|
||||
/// If the child thread panics, `Err` is returned with the parameter given
|
||||
/// to `panic`.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn join(mut self) -> Result<()> {
|
||||
self.0.join()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl Drop for JoinHandle {
|
||||
fn drop(&mut self) {
|
||||
if !self.0.joined {
|
||||
unsafe { imp::detach(self.0.native) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An RAII-style guard that will block until thread termination when dropped.
|
||||
///
|
||||
/// The type `T` is the return type for the thread's main function.
|
||||
///
|
||||
/// Joining on drop is necessary to ensure memory safety when stack
|
||||
/// data is shared between a parent and child thread.
|
||||
///
|
||||
/// Due to platform restrictions, it is not possible to `Clone` this
|
||||
/// handle: the ability to join a child thread is a uniquely-owned
|
||||
/// permission.
|
||||
#[must_use]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub struct JoinGuard<'a, T: 'a>(JoinInner<T>);
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
unsafe impl<'a, T: Send + 'a> Sync for JoinGuard<'a, T> {}
|
||||
|
||||
impl<'a, T: Send + 'a> JoinGuard<'a, T> {
|
||||
/// Extract a handle to the thread this guard will join on.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn thread(&self) -> &Thread {
|
||||
&self.0.thread
|
||||
}
|
||||
|
||||
/// Wait for the associated thread to finish, returning the result of the thread's
|
||||
/// calculation.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics on the child thread are propagated by panicking the parent.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn join(mut self) -> T {
|
||||
match self.0.join() {
|
||||
Ok(res) => res,
|
||||
Err(_) => panic!("child thread {:?} panicked", self.thread()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: Send> JoinGuard<'static, T> {
|
||||
/// Detaches the child thread, allowing it to outlive its parent.
|
||||
#[unstable(feature = "std_misc",
|
||||
reason = "unsure whether this API imposes limitations elsewhere")]
|
||||
#[deprecated(since = "1.0.0", reason = "use spawn instead")]
|
||||
#[unstable(feature = "std_misc")]
|
||||
pub fn detach(mut self) {
|
||||
unsafe { imp::detach(self.native) };
|
||||
self.joined = true; // avoid joining in the destructor
|
||||
unsafe { imp::detach(self.0.native) };
|
||||
self.0.joined = true; // avoid joining in the destructor
|
||||
}
|
||||
}
|
||||
|
||||
@ -529,8 +685,8 @@ impl<T: Send> JoinGuard<'static, T> {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, T: Send + 'a> Drop for JoinGuard<'a, T> {
|
||||
fn drop(&mut self) {
|
||||
if !self.joined {
|
||||
unsafe { imp::join(self.native) };
|
||||
if !self.0.joined {
|
||||
unsafe { imp::join(self.0.native) };
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -544,7 +700,7 @@ mod test {
|
||||
use boxed::BoxAny;
|
||||
use result;
|
||||
use std::old_io::{ChanReader, ChanWriter};
|
||||
use super::{Thread, Builder};
|
||||
use super::{self, Thread, Builder};
|
||||
use thunk::Thunk;
|
||||
use time::Duration;
|
||||
|
||||
@ -553,22 +709,22 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_unnamed_thread() {
|
||||
Thread::scoped(move|| {
|
||||
assert!(Thread::current().name().is_none());
|
||||
thread::spawn(move|| {
|
||||
assert!(thread::current().name().is_none());
|
||||
}).join().ok().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_named_thread() {
|
||||
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();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_run_basic() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
rx.recv().unwrap();
|
||||
@ -576,7 +732,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_join_success() {
|
||||
match Thread::scoped(move|| -> String {
|
||||
match thread::spawn(move|| -> String {
|
||||
"Success!".to_string()
|
||||
}).join().as_ref().map(|s| &**s) {
|
||||
result::Result::Ok("Success!") => (),
|
||||
@ -586,7 +742,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_join_panic() {
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!()
|
||||
}).join() {
|
||||
result::Result::Err(_) => (),
|
||||
@ -594,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]
|
||||
fn test_spawn_sched() {
|
||||
use clone::Clone;
|
||||
@ -602,7 +778,7 @@ mod test {
|
||||
|
||||
fn f(i: int, tx: Sender<()>) {
|
||||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
if i == 0 {
|
||||
tx.send(()).unwrap();
|
||||
} else {
|
||||
@ -619,8 +795,8 @@ mod test {
|
||||
fn test_spawn_sched_childs_on_default_sched() {
|
||||
let (tx, rx) = channel();
|
||||
|
||||
Thread::spawn(move|| {
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
});
|
||||
@ -646,14 +822,14 @@ mod test {
|
||||
#[test]
|
||||
fn test_avoid_copying_the_body_spawn() {
|
||||
avoid_copying_the_body(|v| {
|
||||
Thread::spawn(move || v.invoke(()));
|
||||
thread::spawn(move || v.invoke(()));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_avoid_copying_the_body_thread_spawn() {
|
||||
avoid_copying_the_body(|f| {
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
f.invoke(());
|
||||
});
|
||||
})
|
||||
@ -662,7 +838,7 @@ mod test {
|
||||
#[test]
|
||||
fn test_avoid_copying_the_body_join() {
|
||||
avoid_copying_the_body(|f| {
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
f.invoke(())
|
||||
}).join();
|
||||
})
|
||||
@ -678,21 +854,21 @@ mod test {
|
||||
fn child_no(x: uint) -> Thunk {
|
||||
return Thunk::new(move|| {
|
||||
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]
|
||||
fn test_simple_newsched_spawn() {
|
||||
Thread::spawn(move || {});
|
||||
thread::spawn(move || {});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_try_panic_message_static_str() {
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!("static string");
|
||||
}).join() {
|
||||
Err(e) => {
|
||||
@ -706,7 +882,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_try_panic_message_owned_str() {
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!("owned string".to_string());
|
||||
}).join() {
|
||||
Err(e) => {
|
||||
@ -720,7 +896,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_try_panic_message_any() {
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!(box 413u16 as Box<Any + Send>);
|
||||
}).join() {
|
||||
Err(e) => {
|
||||
@ -738,7 +914,7 @@ mod test {
|
||||
fn test_try_panic_message_unit_struct() {
|
||||
struct Juju;
|
||||
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!(Juju)
|
||||
}).join() {
|
||||
Err(ref e) if e.is::<Juju>() => {}
|
||||
@ -764,15 +940,15 @@ mod test {
|
||||
#[test]
|
||||
fn test_park_timeout_unpark_before() {
|
||||
for _ in 0..10 {
|
||||
Thread::current().unpark();
|
||||
Thread::park_timeout(Duration::seconds(10_000_000));
|
||||
thread::current().unpark();
|
||||
thread::park_timeout(Duration::seconds(10_000_000));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_park_timeout_unpark_not_called() {
|
||||
for _ in 0..10 {
|
||||
Thread::park_timeout(Duration::milliseconds(10));
|
||||
thread::park_timeout(Duration::milliseconds(10));
|
||||
}
|
||||
}
|
||||
|
||||
@ -781,14 +957,14 @@ mod test {
|
||||
use std::old_io;
|
||||
|
||||
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));
|
||||
th.unpark();
|
||||
});
|
||||
|
||||
Thread::park_timeout(Duration::seconds(10_000_000));
|
||||
thread::park_timeout(Duration::seconds(10_000_000));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -72,7 +72,7 @@ pub mod __impl {
|
||||
///
|
||||
/// ```
|
||||
/// use std::cell::RefCell;
|
||||
/// use std::thread::Thread;
|
||||
/// use std::thread;
|
||||
///
|
||||
/// 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
|
||||
/// Thread::spawn(move|| {
|
||||
/// thread::spawn(move|| {
|
||||
/// FOO.with(|f| {
|
||||
/// assert_eq!(*f.borrow(), 1);
|
||||
/// *f.borrow_mut() = 3;
|
||||
@ -548,7 +548,7 @@ mod tests {
|
||||
use sync::mpsc::{channel, Sender};
|
||||
use cell::UnsafeCell;
|
||||
use super::State;
|
||||
use thread::Thread;
|
||||
use thread;
|
||||
|
||||
struct Foo(Sender<()>);
|
||||
|
||||
@ -568,7 +568,7 @@ mod tests {
|
||||
*f.get() = 2;
|
||||
});
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
FOO.with(|f| unsafe {
|
||||
assert_eq!(*f.get(), 1);
|
||||
});
|
||||
@ -595,7 +595,7 @@ mod tests {
|
||||
}
|
||||
thread_local!(static FOO: Foo = foo());
|
||||
|
||||
Thread::scoped(|| {
|
||||
thread::spawn(|| {
|
||||
assert!(FOO.state() == State::Uninitialized);
|
||||
FOO.with(|_| {
|
||||
assert!(FOO.state() == State::Valid);
|
||||
@ -611,7 +611,7 @@ mod tests {
|
||||
});
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| unsafe {
|
||||
let _t = thread::spawn(move|| unsafe {
|
||||
let mut tx = Some(tx);
|
||||
FOO.with(|f| {
|
||||
*f.get() = Some(Foo(tx.take().unwrap()));
|
||||
@ -659,7 +659,7 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(S1);
|
||||
}).join().ok().unwrap();
|
||||
}
|
||||
@ -677,7 +677,7 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
Thread::scoped(move|| unsafe {
|
||||
thread::spawn(move|| unsafe {
|
||||
K1.with(|s| *s.get() = Some(S1));
|
||||
}).join().ok().unwrap();
|
||||
}
|
||||
@ -704,7 +704,7 @@ mod tests {
|
||||
}
|
||||
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| unsafe {
|
||||
let _t = thread::spawn(move|| unsafe {
|
||||
let mut tx = Some(tx);
|
||||
K1.with(|s| *s.get() = Some(S1(tx.take().unwrap())));
|
||||
});
|
||||
|
||||
@ -84,7 +84,7 @@ macro_rules! __scoped_thread_local_inner {
|
||||
target_os = "openbsd",
|
||||
target_arch = "aarch64")),
|
||||
thread_local)]
|
||||
static $name: ::std::thread_local::scoped::Key<$t> =
|
||||
static $name: ::std::thread_local::spawn::Key<$t> =
|
||||
__scoped_thread_local_inner!($t);
|
||||
);
|
||||
(pub static $name:ident: $t:ty) => (
|
||||
@ -94,11 +94,11 @@ macro_rules! __scoped_thread_local_inner {
|
||||
target_os = "openbsd",
|
||||
target_arch = "aarch64")),
|
||||
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);
|
||||
);
|
||||
($t:ty) => ({
|
||||
use std::thread_local::scoped::Key as __Key;
|
||||
use std::thread_local::spawn::Key as __Key;
|
||||
|
||||
#[cfg(not(any(windows,
|
||||
target_os = "android",
|
||||
@ -106,7 +106,7 @@ macro_rules! __scoped_thread_local_inner {
|
||||
target_os = "openbsd",
|
||||
target_arch = "aarch64")))]
|
||||
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 _ },
|
||||
}
|
||||
};
|
||||
@ -117,8 +117,8 @@ macro_rules! __scoped_thread_local_inner {
|
||||
target_os = "openbsd",
|
||||
target_arch = "aarch64"))]
|
||||
const _INIT: __Key<$t> = __Key {
|
||||
inner: ::std::thread_local::scoped::__impl::KeyInner {
|
||||
inner: ::std::thread_local::scoped::__impl::OS_INIT,
|
||||
inner: ::std::thread_local::spawn::__impl::KeyInner {
|
||||
inner: ::std::thread_local::spawn::__impl::OS_INIT,
|
||||
marker: ::std::marker::InvariantType,
|
||||
}
|
||||
};
|
||||
|
||||
@ -879,7 +879,7 @@ pub fn run_test(opts: &TestOpts,
|
||||
monitor_ch: Sender<MonitorMsg>,
|
||||
nocapture: bool,
|
||||
testfn: Thunk) {
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
let (tx, rx) = channel();
|
||||
let mut reader = ChanReader::new(rx);
|
||||
let stdout = ChanWriter::new(tx.clone());
|
||||
|
||||
@ -8,12 +8,12 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::sync::mpsc::{Receiver, channel};
|
||||
|
||||
pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(x.clone());
|
||||
});
|
||||
rx
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
fn move_out<T>(_x: T) {}
|
||||
@ -63,7 +63,7 @@ fn run(args: &[String]) {
|
||||
let mut worker_results = Vec::new();
|
||||
for _ in 0u..workers {
|
||||
let to_child = to_child.clone();
|
||||
worker_results.push(Thread::scoped(move|| {
|
||||
worker_results.push(thread::spawn(move|| {
|
||||
for _ in 0u..size / workers {
|
||||
//println!("worker {}: sending {} bytes", i, num_bytes);
|
||||
to_child.send(request::bytes(num_bytes)).unwrap();
|
||||
@ -71,7 +71,7 @@ fn run(args: &[String]) {
|
||||
//println!("worker {} exiting", i);
|
||||
}));
|
||||
}
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
server(&from_parent, &to_parent);
|
||||
});
|
||||
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
enum request {
|
||||
@ -56,7 +56,7 @@ fn run(args: &[String]) {
|
||||
let mut worker_results = Vec::new();
|
||||
let from_parent = if workers == 1 {
|
||||
let (to_child, from_parent) = channel();
|
||||
worker_results.push(Thread::scoped(move|| {
|
||||
worker_results.push(thread::spawn(move|| {
|
||||
for _ in 0u..size / workers {
|
||||
//println!("worker {}: sending {} bytes", i, num_bytes);
|
||||
to_child.send(request::bytes(num_bytes));
|
||||
@ -68,7 +68,7 @@ fn run(args: &[String]) {
|
||||
let (to_child, from_parent) = channel();
|
||||
for _ in 0u..workers {
|
||||
let to_child = to_child.clone();
|
||||
worker_results.push(Thread::scoped(move|| {
|
||||
worker_results.push(thread::spawn(move|| {
|
||||
for _ in 0u..size / workers {
|
||||
//println!("worker {}: sending {} bytes", i, num_bytes);
|
||||
to_child.send(request::bytes(num_bytes));
|
||||
@ -78,7 +78,7 @@ fn run(args: &[String]) {
|
||||
}
|
||||
from_parent
|
||||
};
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
server(&from_parent, &to_parent);
|
||||
});
|
||||
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
|
||||
use std::sync::mpsc::channel;
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
// 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
|
||||
@ -35,7 +35,7 @@ fn ping_pong_bench(n: usize, m: usize) {
|
||||
// Create a channel: B->A
|
||||
let (btx, brx) = channel();
|
||||
|
||||
let guard_a = Thread::scoped(move|| {
|
||||
let guard_a = thread::spawn(move|| {
|
||||
let (tx, rx) = (atx, brx);
|
||||
for _ in 0..n {
|
||||
tx.send(()).unwrap();
|
||||
@ -43,7 +43,7 @@ fn ping_pong_bench(n: usize, m: usize) {
|
||||
}
|
||||
});
|
||||
|
||||
let guard_b = Thread::scoped(move|| {
|
||||
let guard_b = thread::spawn(move|| {
|
||||
let (tx, rx) = (btx, arx);
|
||||
for _ in 0..n {
|
||||
rx.recv().unwrap();
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
use std::sync::mpsc::channel;
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
// A simple implementation of parfib. One subtree is found in a new
|
||||
// task and communicated over a oneshot pipe, the other is found
|
||||
@ -22,7 +22,7 @@ fn parfib(n: u64) -> u64 {
|
||||
}
|
||||
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(parfib(n-1)).unwrap();
|
||||
});
|
||||
let m2 = parfib(n-2);
|
||||
|
||||
@ -110,7 +110,7 @@ fn main() {
|
||||
let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
|
||||
use std::num::Int;
|
||||
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<_>>();
|
||||
|
||||
for message in messages {
|
||||
|
||||
@ -43,7 +43,7 @@
|
||||
use self::Color::{Red, Yellow, Blue};
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::fmt;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn print_complements() {
|
||||
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_log = to_rendezvous_log.clone();
|
||||
let (to_creature, from_rendezvous) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
creature(ii,
|
||||
col,
|
||||
from_rendezvous,
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
// OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
use std::{cmp, iter, mem};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn rotate(x: &mut [i32]) {
|
||||
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)) {
|
||||
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)
|
||||
}))
|
||||
}
|
||||
|
||||
@ -24,7 +24,7 @@ use std::option;
|
||||
use std::os;
|
||||
use std::env;
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn f64_cmp(x: f64, y: f64) -> Ordering {
|
||||
// arbitrarily decide that NaNs are larger than everything.
|
||||
@ -172,7 +172,7 @@ fn main() {
|
||||
|
||||
let (to_child, from_parent) = channel();
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
make_sequence_processor(sz, &from_parent, &to_parent_);
|
||||
});
|
||||
|
||||
|
||||
@ -45,7 +45,7 @@
|
||||
use std::ascii::OwnedAsciiExt;
|
||||
use std::slice;
|
||||
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_SIZE: uint = 2 << 16;
|
||||
@ -303,11 +303,11 @@ fn main() {
|
||||
|
||||
let nb_freqs: Vec<_> = (1u..3).map(|i| {
|
||||
let input = input.clone();
|
||||
(i, Thread::scoped(move|| generate_frequencies(&input, i)))
|
||||
(i, thread::spawn(move|| generate_frequencies(&input, i)))
|
||||
}).collect();
|
||||
let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| {
|
||||
let input = input.clone();
|
||||
Thread::scoped(move|| generate_frequencies(&input, occ.len()))
|
||||
thread::spawn(move|| generate_frequencies(&input, occ.len()))
|
||||
}).collect();
|
||||
|
||||
for (i, freq) in nb_freqs {
|
||||
|
||||
@ -46,7 +46,7 @@ use std::old_io;
|
||||
use std::env;
|
||||
use std::simd::f64x2;
|
||||
use std::sync::Arc;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
const ITER: usize = 50;
|
||||
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 precalc_futures = (0..WORKERS).map(|i| {
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut rs = 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_i = arc_init_i.clone();
|
||||
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8);
|
||||
let init_r_slice = vec_init_r;
|
||||
|
||||
|
||||
@ -43,7 +43,7 @@
|
||||
use std::iter::repeat;
|
||||
use std::sync::Arc;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
//
|
||||
// Utilities.
|
||||
@ -317,7 +317,7 @@ fn par_search(masks: Vec<Vec<Vec<u64>>>) -> Data {
|
||||
let masks = masks.clone();
|
||||
let tx = tx.clone();
|
||||
let m = *m;
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
let mut data = Data::new();
|
||||
search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data);
|
||||
tx.send(data).unwrap();
|
||||
|
||||
@ -23,7 +23,7 @@ extern crate getopts;
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::env;
|
||||
use std::result::Result::{Ok, Err};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
fn fib(n: isize) -> isize {
|
||||
@ -35,15 +35,15 @@ fn fib(n: isize) -> isize {
|
||||
} else {
|
||||
let (tx1, rx) = channel();
|
||||
let tx2 = tx1.clone();
|
||||
Thread::spawn(move|| pfib(&tx2, n - 1));
|
||||
thread::spawn(move|| pfib(&tx2, n - 1));
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| pfib(&tx, n) );
|
||||
thread::spawn(move|| pfib(&tx, n) );
|
||||
rx.recv().unwrap()
|
||||
}
|
||||
|
||||
@ -78,7 +78,7 @@ fn stress_task(id: isize) {
|
||||
fn stress(num_tasks: int) {
|
||||
let mut results = Vec::new();
|
||||
for i in 0..num_tasks {
|
||||
results.push(Thread::scoped(move|| {
|
||||
results.push(thread::spawn(move|| {
|
||||
stress_task(i);
|
||||
}));
|
||||
}
|
||||
|
||||
@ -47,7 +47,7 @@ extern crate libc;
|
||||
use std::old_io::stdio::{stdin_raw, stdout_raw};
|
||||
use std::old_io::{IoResult, EndOfFile};
|
||||
use std::ptr::{copy_memory, Unique};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
struct Tables {
|
||||
table8: [u8;1 << 8],
|
||||
@ -241,7 +241,7 @@ fn parallel<'a, I, T, F>(iter: I, f: F)
|
||||
// boundary.
|
||||
let f = Racy(&f as *const F as *const uint);
|
||||
let raw = Racy(chunk.repr());
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
let f = f.0 as *const F;
|
||||
unsafe { (*f)(mem::transmute(raw.0)) }
|
||||
})
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
#![feature(unboxed_closures)]
|
||||
|
||||
use std::iter::{repeat, AdditiveIterator};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::mem;
|
||||
use std::num::Float;
|
||||
use std::os;
|
||||
@ -129,7 +129,7 @@ fn parallel<T, F>(v: &mut [T], f: F)
|
||||
// boundary.
|
||||
let f = Racy(&f as *const _ as *const uint);
|
||||
let raw = Racy(chunk.repr());
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
let f = f.0 as *const F;
|
||||
unsafe { (*f)(i * size, mem::transmute(raw.0)) }
|
||||
})
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
// OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn start(n_tasks: i32, token: i32) {
|
||||
let (tx, mut rx) = channel();
|
||||
@ -48,9 +48,9 @@ fn start(n_tasks: i32, token: i32) {
|
||||
for i in 2 .. n_tasks + 1 {
|
||||
let (tx, next_rx) = channel();
|
||||
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>) {
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#![feature(unsafe_destructor, box_syntax)]
|
||||
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
#[derive(Clone)]
|
||||
@ -32,7 +32,7 @@ fn main() {
|
||||
fn run(repeat: int, depth: int) {
|
||||
for _ in 0..repeat {
|
||||
let dur = Duration::span(|| {
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
recurse_or_panic(depth, None)
|
||||
}).join();
|
||||
});
|
||||
|
||||
@ -19,15 +19,15 @@
|
||||
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn child_generation(gens_left: uint, tx: Sender<()>) {
|
||||
// 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
|
||||
// alive at a time,
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
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 {
|
||||
child_generation(gens_left - 1, tx); // recurse
|
||||
|
||||
@ -9,12 +9,12 @@
|
||||
// except according to those terms.
|
||||
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn f(n: usize) {
|
||||
let mut i = 0u;
|
||||
while i < n {
|
||||
let _ = Thread::scoped(move|| g()).join();
|
||||
let _ = thread::spawn(move|| g()).join();
|
||||
i += 1u;
|
||||
}
|
||||
}
|
||||
@ -32,5 +32,5 @@ fn main() {
|
||||
};
|
||||
let n = args[1].parse().unwrap();
|
||||
let mut i = 0;
|
||||
while i < n { Thread::spawn(move|| f(n) ); i += 1u; }
|
||||
while i < n { thread::spawn(move|| f(n) ); i += 1; }
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
#![feature(box_syntax)]
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
|
||||
f(v);
|
||||
@ -19,7 +19,7 @@ fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
|
||||
fn box_imm() {
|
||||
let v = box 3;
|
||||
let _w = &v;
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
println!("v={}", *v);
|
||||
//~^ ERROR cannot move `v` into closure
|
||||
});
|
||||
@ -28,7 +28,7 @@ fn box_imm() {
|
||||
fn box_imm_explicit() {
|
||||
let v = box 3;
|
||||
let _w = &v;
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
println!("v={}", *v);
|
||||
//~^ ERROR cannot move
|
||||
});
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
#![feature(box_syntax)]
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn borrow<T>(_: &T) { }
|
||||
|
||||
@ -19,7 +19,7 @@ fn different_vars_after_borrows() {
|
||||
let p1 = &x1;
|
||||
let x2 = box 2;
|
||||
let p2 = &x2;
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(x1); //~ ERROR cannot move `x1` 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);
|
||||
let x2 = box 2;
|
||||
drop(x2);
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(x1); //~ ERROR capture of moved value: `x1`
|
||||
drop(x2); //~ ERROR capture of moved value: `x2`
|
||||
});
|
||||
@ -41,7 +41,7 @@ fn different_vars_after_moves() {
|
||||
fn same_var_after_borrow() {
|
||||
let x = box 1;
|
||||
let p = &x;
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(x); //~ ERROR cannot move `x` into closure because it is borrowed
|
||||
drop(x); //~ ERROR use of moved value: `x`
|
||||
});
|
||||
@ -51,7 +51,7 @@ fn same_var_after_borrow() {
|
||||
fn same_var_after_move() {
|
||||
let x = box 1;
|
||||
drop(x);
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
drop(x); //~ ERROR capture of moved value: `x`
|
||||
drop(x); //~ ERROR use of moved value: `x`
|
||||
});
|
||||
|
||||
@ -9,11 +9,11 @@
|
||||
// except according to those terms.
|
||||
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| -> () {
|
||||
let _t = thread::spawn(move|| -> () {
|
||||
loop {
|
||||
let tx = tx;
|
||||
//~^ ERROR: use of moved value: `tx`
|
||||
|
||||
@ -9,47 +9,47 @@
|
||||
// except according to those terms.
|
||||
|
||||
use std::{int, i8, i16, i32, i64};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
}
|
||||
|
||||
@ -30,4 +30,4 @@ pub mod bar {
|
||||
// #[stable] is not inherited
|
||||
pub fn unmarked() {}
|
||||
//~^ ERROR This node does not have a stability attribute
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,11 +8,11 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let x = "Hello world!".to_string();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
println!("{}", x);
|
||||
});
|
||||
println!("{}", x); //~ ERROR use of moved value
|
||||
|
||||
@ -11,13 +11,13 @@
|
||||
// error-pattern: use of moved value
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
|
||||
let arc_v = Arc::new(v);
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
assert_eq!((*arc_v)[3], 4);
|
||||
});
|
||||
|
||||
|
||||
@ -9,13 +9,13 @@
|
||||
// except according to those terms.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
|
||||
let arc_v = Arc::new(v);
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
assert_eq!((*arc_v)[3], 4);
|
||||
});
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
#![feature(unsafe_destructor)]
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::rc::Rc;
|
||||
|
||||
#[derive(Debug)]
|
||||
@ -35,7 +35,7 @@ fn main() {
|
||||
|
||||
let x = foo(Port(Rc::new(())));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
//~^ ERROR `core::marker::Send` is not implemented
|
||||
let y = x;
|
||||
println!("{:?}", y);
|
||||
|
||||
@ -10,10 +10,10 @@
|
||||
|
||||
// error-pattern:thread '<unnamed>' panicked at 'test'
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let r: Result<int,_> = Thread::scoped(move|| {
|
||||
let r: Result<int,_> = thread::spawn(move|| {
|
||||
panic!("test");
|
||||
1
|
||||
}).join();
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
|
||||
#[macro_use] extern crate log;
|
||||
use std::os;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
struct r {
|
||||
x:int,
|
||||
@ -35,7 +35,7 @@ fn r(x:int) -> r {
|
||||
|
||||
fn main() {
|
||||
error!("whatever");
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _t = thread::spawn(move|| {
|
||||
let _i = r(5);
|
||||
});
|
||||
panic!();
|
||||
|
||||
@ -10,12 +10,12 @@
|
||||
|
||||
// error-pattern:Ensure that the child task runs by panicking
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
// the purpose of this test is to make sure that task::spawn()
|
||||
// works when provided with a bare function:
|
||||
let r = Thread::scoped(startfn).join();
|
||||
let r = thread::spawn(startfn).join();
|
||||
if r.is_err() {
|
||||
panic!()
|
||||
}
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
#![feature(box_syntax)]
|
||||
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn child(tx: &Sender<Box<uint>>, i: uint) {
|
||||
tx.send(box i).unwrap();
|
||||
@ -25,7 +25,7 @@ pub fn main() {
|
||||
let _t = (0u..n).map(|i| {
|
||||
expected += i;
|
||||
let tx = tx.clone();
|
||||
Thread::scoped(move|| {
|
||||
thread::spawn(move|| {
|
||||
child(&tx, i)
|
||||
})
|
||||
}).collect::<Vec<_>>();
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
// Make sure the destructor is run for unit-like structs.
|
||||
|
||||
use std::boxed::BoxAny;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
struct Foo;
|
||||
|
||||
@ -22,7 +22,7 @@ impl Drop for Foo {
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let x = Thread::scoped(move|| {
|
||||
let x = thread::spawn(move|| {
|
||||
let _b = Foo;
|
||||
}).join();
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
// except according to those terms.
|
||||
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
struct complainer {
|
||||
tx: Sender<bool>,
|
||||
@ -37,7 +37,7 @@ fn f(tx: Sender<bool>) {
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::scoped(move|| f(tx.clone()));
|
||||
let _t = thread::spawn(move|| f(tx.clone()));
|
||||
println!("hiiiiiiiii");
|
||||
assert!(rx.recv().unwrap());
|
||||
}
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#![allow(unknown_features)]
|
||||
#![feature(box_syntax)]
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn f() {
|
||||
let _a = box 0;
|
||||
@ -19,5 +19,5 @@ fn f() {
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let _t = Thread::scoped(f);
|
||||
let _t = thread::spawn(f);
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
|
||||
use std::rand::{thread_rng, Rng, Rand};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
const REPEATS: usize = 5;
|
||||
const MAX_LEN: usize = 32;
|
||||
@ -79,7 +79,7 @@ pub fn main() {
|
||||
|
||||
let v = main.clone();
|
||||
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
let mut v = v;
|
||||
let mut panic_countdown = panic_countdown;
|
||||
v.sort_by(|a, b| {
|
||||
|
||||
@ -12,10 +12,10 @@
|
||||
|
||||
extern crate "weak-lang-items" as other;
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
let _ = Thread::scoped(move|| {
|
||||
let _ = thread::spawn(move|| {
|
||||
other::foo()
|
||||
});
|
||||
}
|
||||
|
||||
@ -8,18 +8,18 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
pub fn main() {
|
||||
let mut result = Thread::scoped(child);
|
||||
let mut result = thread::spawn(child);
|
||||
println!("1");
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
println!("2");
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
println!("3");
|
||||
result.join();
|
||||
}
|
||||
|
||||
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");
|
||||
}
|
||||
|
||||
@ -8,12 +8,12 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
pub fn main() {
|
||||
let mut result = Thread::scoped(child);
|
||||
let mut result = thread::spawn(child);
|
||||
println!("1");
|
||||
Thread::yield_now();
|
||||
thread::yield_now();
|
||||
result.join();
|
||||
}
|
||||
|
||||
|
||||
@ -8,9 +8,9 @@
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
pub fn main() {
|
||||
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(); }
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user