mirror of https://github.com/rust-lang/rust.git
Fallout from stabilization
This commit is contained in:
Aaron Turon
parent
d8f8f7a58c
commit
d0de2b46e9
|
|
@ -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);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -935,7 +935,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;
|
||||
|
||||
|
|
@ -1284,7 +1284,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());
|
||||
|
|
@ -256,7 +256,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]));
|
||||
|
|
@ -273,7 +273,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]));
|
||||
});
|
||||
|
|
@ -289,7 +289,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]));
|
||||
});
|
||||
|
|
@ -306,7 +306,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();
|
||||
|
|
@ -325,7 +325,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
|
||||
});
|
||||
|
|
@ -345,7 +345,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();
|
||||
});
|
||||
|
|
@ -371,7 +371,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]));
|
||||
|
|
@ -393,11 +393,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));
|
||||
|
|
@ -412,7 +412,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);
|
||||
|
|
@ -428,10 +428,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));
|
||||
|
|
@ -446,7 +446,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]));
|
||||
|
|
@ -467,7 +467,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());
|
||||
});
|
||||
|
||||
|
|
@ -481,7 +481,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];
|
||||
|
|
@ -517,7 +517,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));
|
||||
});
|
||||
|
||||
|
|
@ -532,7 +532,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));
|
||||
|
|
@ -545,7 +545,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]));
|
||||
|
|
@ -565,7 +565,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();
|
||||
|
|
@ -577,7 +577,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));
|
||||
|
|
@ -597,7 +597,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));
|
||||
|
|
@ -608,7 +608,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();
|
||||
|
|
@ -623,7 +623,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));
|
||||
|
|
@ -644,7 +644,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();
|
||||
});
|
||||
|
|
@ -682,7 +682,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();
|
||||
});
|
||||
|
|
@ -690,7 +690,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();
|
||||
|
|
@ -713,7 +713,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]));
|
||||
|
|
@ -724,7 +724,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();
|
||||
|
|
@ -732,7 +732,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
|
||||
|
|
@ -750,10 +750,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);
|
||||
});
|
||||
|
||||
|
|
@ -771,17 +771,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::*;
|
||||
|
|
@ -520,7 +520,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();
|
||||
});
|
||||
|
|
@ -536,7 +536,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();
|
||||
});
|
||||
|
|
@ -552,7 +552,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();
|
||||
});
|
||||
|
|
@ -568,7 +568,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();
|
||||
});
|
||||
|
|
@ -584,7 +584,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();
|
||||
});
|
||||
|
|
@ -600,7 +600,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();
|
||||
});
|
||||
|
|
@ -616,7 +616,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
|
||||
});
|
||||
|
|
@ -632,7 +632,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
|
||||
});
|
||||
|
|
@ -648,7 +648,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
|
||||
});
|
||||
|
|
@ -672,7 +672,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
|
||||
});
|
||||
|
|
@ -697,7 +697,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();
|
||||
});
|
||||
|
|
@ -722,7 +722,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();
|
||||
});
|
||||
|
|
@ -747,7 +747,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();
|
||||
|
|
@ -767,7 +767,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();
|
||||
|
|
@ -787,11 +787,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();
|
||||
|
|
@ -806,7 +806,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
|
||||
|
|
@ -823,11 +823,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();
|
||||
|
|
@ -842,7 +842,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
|
||||
|
|
@ -859,11 +859,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();
|
||||
|
|
@ -878,7 +878,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
|
||||
|
|
@ -895,11 +895,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();
|
||||
|
|
@ -914,7 +914,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
|
||||
|
|
@ -937,7 +937,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();
|
||||
});
|
||||
|
|
@ -972,7 +972,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();
|
||||
|
|
@ -1009,7 +1009,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
|
||||
|
|
@ -1034,7 +1034,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));
|
||||
|
|
@ -1047,7 +1047,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();
|
||||
|
|
@ -1066,7 +1066,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();
|
||||
|
|
@ -1078,7 +1078,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();
|
||||
|
|
@ -1097,7 +1097,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();
|
||||
|
|
@ -1108,7 +1108,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();
|
||||
|
|
@ -1122,7 +1122,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!()));
|
||||
|
|
@ -1156,7 +1156,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();
|
||||
|
|
@ -1166,14 +1166,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();
|
||||
|
|
@ -1184,7 +1184,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();
|
||||
|
|
@ -1221,7 +1221,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();
|
||||
|
|
@ -1230,7 +1230,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();
|
||||
|
|
@ -1247,7 +1247,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());
|
||||
|
|
@ -1280,7 +1280,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;
|
||||
|
|
@ -1309,7 +1309,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());
|
||||
|
|
@ -1337,7 +1337,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(()));
|
||||
|
|
@ -1347,7 +1347,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();
|
||||
|
|
@ -1370,7 +1370,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();
|
||||
|
|
@ -1381,7 +1381,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();
|
||||
|
|
@ -1389,7 +1389,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
|
||||
|
|
@ -1407,10 +1407,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);
|
||||
});
|
||||
|
||||
|
|
@ -1428,19 +1428,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);
|
||||
});
|
||||
|
||||
|
|
@ -1466,7 +1466,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.
|
||||
//!
|
||||
|
|
|
|||
|
|
@ -42,23 +42,23 @@
|
|||
//! 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;
|
||||
//!
|
||||
//! Thread::spawn(move || {
|
||||
//! thread::spawn(move || {
|
||||
//! println!("Hello, World!");
|
||||
//! // some computation here
|
||||
//! });
|
||||
|
|
@ -76,14 +76,14 @@
|
|||
//! 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,
|
||||
|
|
@ -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
|
||||
|
|
@ -411,7 +411,7 @@ pub fn panicking() -> bool {
|
|||
// or futuxes, and in either case may allow spurious wakeups.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
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();
|
||||
|
|
@ -431,7 +431,7 @@ pub fn park() {
|
|||
/// 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 = 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();
|
||||
|
|
@ -512,7 +512,7 @@ impl Thread {
|
|||
#[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();
|
||||
|
|
@ -524,7 +524,7 @@ impl Thread {
|
|||
#[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();
|
||||
|
|
@ -700,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;
|
||||
|
||||
|
|
@ -709,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();
|
||||
|
|
@ -732,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!") => (),
|
||||
|
|
@ -742,7 +742,7 @@ mod test {
|
|||
|
||||
#[test]
|
||||
fn test_join_panic() {
|
||||
match Thread::scoped(move|| {
|
||||
match thread::spawn(move|| {
|
||||
panic!()
|
||||
}).join() {
|
||||
result::Result::Err(_) => (),
|
||||
|
|
@ -750,6 +750,26 @@ mod test {
|
|||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_scoped_success() {
|
||||
let res = thread::scoped(move|| -> String {
|
||||
"Success!".to_string()
|
||||
}).join();
|
||||
assert!(res == "Success!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_fail]
|
||||
fn test_scoped_panic() {
|
||||
thread::scoped(|| panic!()).join();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_fail]
|
||||
fn test_scoped_implicit_panic() {
|
||||
thread::scoped(|| panic!());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_spawn_sched() {
|
||||
use clone::Clone;
|
||||
|
|
@ -758,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 {
|
||||
|
|
@ -775,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();
|
||||
});
|
||||
});
|
||||
|
|
@ -802,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(());
|
||||
});
|
||||
})
|
||||
|
|
@ -818,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();
|
||||
})
|
||||
|
|
@ -834,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) => {
|
||||
|
|
@ -862,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) => {
|
||||
|
|
@ -876,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) => {
|
||||
|
|
@ -894,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>() => {}
|
||||
|
|
@ -920,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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -937,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
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::os;
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
fn move_out<T>(_x: T) {}
|
||||
|
|
@ -64,7 +64,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();
|
||||
|
|
@ -72,7 +72,7 @@ fn run(args: &[String]) {
|
|||
//println!("worker {} exiting", i);
|
||||
}));
|
||||
}
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
server(&from_parent, &to_parent);
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::os;
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
enum request {
|
||||
|
|
@ -57,7 +57,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));
|
||||
|
|
@ -69,7 +69,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));
|
||||
|
|
@ -79,7 +79,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::os;
|
||||
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: uint, m: uint) {
|
|||
// 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: uint, m: uint) {
|
|||
}
|
||||
});
|
||||
|
||||
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::os;
|
||||
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: uint) -> uint {
|
|||
}
|
||||
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
thread::spawn(move|| {
|
||||
tx.send(parfib(n-1)).unwrap();
|
||||
});
|
||||
let m2 = parfib(n-2);
|
||||
|
|
|
|||
|
|
@ -111,7 +111,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::os;
|
||||
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();
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ use std::sync::mpsc::{channel, Sender};
|
|||
use std::os;
|
||||
use std::env;
|
||||
use std::result::Result::{Ok, Err};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
fn fib(n: int) -> int {
|
||||
|
|
@ -36,15 +36,15 @@ fn fib(n: int) -> int {
|
|||
} 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()
|
||||
}
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ fn stress_task(id: int) {
|
|||
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();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -20,15 +20,15 @@
|
|||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::os;
|
||||
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
|
||||
|
|
|
|||
|
|
@ -10,12 +10,12 @@
|
|||
|
||||
use std::os;
|
||||
use std::env;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
fn f(n: uint) {
|
||||
let mut i = 0u;
|
||||
while i < n {
|
||||
let _ = Thread::scoped(move|| g()).join();
|
||||
let _ = thread::spawn(move|| g()).join();
|
||||
i += 1u;
|
||||
}
|
||||
}
|
||||
|
|
@ -33,5 +33,5 @@ fn main() {
|
|||
};
|
||||
let n = args[1].parse().unwrap();
|
||||
let mut i = 0u;
|
||||
while i < n { Thread::spawn(move|| f(n) ); i += 1u; }
|
||||
while i < n { thread::spawn(move|| f(n) ); i += 1u; }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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