loop {
//waiting 1 second for gdbserver start
timer::sleep(Duration::milliseconds(1000));
- let result = Thread::spawn(move || {
+ let result = Thread::scoped(move || {
tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
}).join();
if result.is_err() {
for _ in range(0u, 10u) {
Thread::spawn(move || {
println!("Hello, world!");
- }).detach();
+ });
}
}
```
double bars `||`. (The `move` keyword indicates that the closure takes
ownership of any data it uses; we'll have more on the significance of
this shortly.) This closure is executed in a new thread created by
-`spawn`. The `detach` method means that the child thread is allowed to
-outlive its parent.
+`spawn`.
One common form of problem in concurrent programs is a 'data race.'
This occurs when two different threads attempt to access the same
for i in range(0u, 3u) {
Thread::spawn(move || {
for j in range(0, 3) { numbers[j] += 1 }
- }).detach();
+ });
}
}
```
(*array)[i] += 1;
println!("numbers[{}] is {}", i, (*array)[i]);
- }).detach();
+ });
}
}
```
//!
//! Thread::spawn(move || {
//! println!("{}", five);
-//! }).detach();
+//! });
//! }
//! ```
//!
//! *number += 1;
//!
//! println!("{}", *number); // prints 6
-//! }).detach();
+//! });
//! }
//! ```
/// let local_numbers = child_numbers.as_slice();
///
/// // Work with the local numbers
-/// }).detach();
+/// });
/// }
/// }
/// ```
#[test]
fn test_send() {
let n = list_from(&[1i,2,3]);
- Thread::spawn(move || {
+ Thread::scoped(move || {
check_links(&n);
let a: &[_] = &[&1,&2,&3];
assert_eq!(a, n.iter().collect::<Vec<&int>>());
//! let spinlock_clone = spinlock.clone();
//! Thread::spawn(move|| {
//! spinlock_clone.store(0, Ordering::SeqCst);
-//! }).detach();
+//! });
//!
//! // Wait for the other task to release the lock
//! while spinlock.load(Ordering::SeqCst) != 0 {}
cfg = cfg.stack_size(STACK_SIZE);
}
- match cfg.spawn(move || { std::io::stdio::set_stderr(box w); f() }).join() {
+ match cfg.scoped(move || { std::io::stdio::set_stderr(box w); f() }).join() {
Ok(()) => { /* fallthrough */ }
Err(value) => {
// Thread panicked without emitting a fatal diagnostic
}
tx.take().unwrap().send(()).unwrap();
- }).detach();
+ });
}
let mut panicked = false;
pub fn main() {
static STACK_SIZE: uint = 32000000; // 32MB
- let res = std::thread::Builder::new().stack_size(STACK_SIZE).spawn(move || {
+ let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || {
main_args(std::os::args().as_slice())
}).join();
std::os::set_exit_status(res.map_err(|_| ()).unwrap());
let cr = Path::new(cratefile);
info!("starting to run rustc");
- let (mut krate, analysis) = std::thread::Thread::spawn(move |:| {
+ let (mut krate, analysis) = std::thread::Thread::scoped(move |:| {
let cr = cr;
core::run_core(paths, cfgs, externs, &cr, triple)
}).join().map_err(|_| "rustc failed").unwrap();
None => box io::stderr() as Box<Writer>,
};
io::util::copy(&mut p, &mut err).unwrap();
- }).detach();
+ });
let emitter = diagnostic::EmitterWriter::new(box w2, None);
// Compile the code
tx.send(vec![3u8, 4u8]).unwrap();
tx.send(vec![5u8, 6u8]).unwrap();
tx.send(vec![7u8, 8u8]).unwrap();
- }).detach();
+ });
let mut reader = ChanReader::new(rx);
let mut buf = [0u8; 3];
tx.send(b"rld\nhow ".to_vec()).unwrap();
tx.send(b"are you?".to_vec()).unwrap();
tx.send(b"".to_vec()).unwrap();
- }).detach();
+ });
let mut reader = ChanReader::new(rx);
writer.write_be_u32(42).unwrap();
let wanted = vec![0u8, 0u8, 0u8, 42u8];
- let got = match Thread::spawn(move|| { rx.recv().unwrap() }).join() {
+ let got = match Thread::scoped(move|| { rx.recv().unwrap() }).join() {
Ok(got) => got,
Err(_) => panic!(),
};
//! for stream in acceptor.incoming() {
//! match stream {
//! Err(e) => { /* connection failed */ }
-//! Ok(stream) => Thread::spawn(move|| {
-//! // connection succeeded
-//! handle_client(stream)
-//! }).detach()
+//! Ok(stream) => {
+//! Thread::spawn(move|| {
+//! // connection succeeded
+//! handle_client(stream)
+//! });
+//! }
//! }
//! }
//!
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv();
- }).detach();
+ });
let mut b = [0];
let mut s = UnixStream::connect(&addr).unwrap();
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv();
- }).detach();
+ });
let mut s = UnixStream::connect(&addr).unwrap();
let s2 = s.clone();
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_timeout(Some(20));
}
}
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_read_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
let s2 = s.clone();
/// timer::sleep(Duration::seconds(1));
/// let mut stream = stream2;
/// stream.close_read();
- /// }).detach();
+ /// });
///
/// // wait for some data, will get canceled after one second
/// let mut buf = [0];
/// for stream in acceptor.incoming() {
/// match stream {
/// Err(e) => { /* connection failed */ }
-/// Ok(stream) => Thread::spawn(move|| {
-/// // connection succeeded
-/// handle_client(stream)
-/// }).detach()
+/// Ok(stream) => {
+/// Thread::spawn(move|| {
+/// // connection succeeded
+/// handle_client(stream)
+/// });
+/// }
/// }
/// }
///
/// Err(e) => panic!("unexpected error: {}", e),
/// }
/// }
- /// }).detach();
+ /// });
///
/// # fn wait_for_sigint() {}
/// // Now that our accept loop is running, wait for the program to be
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv().unwrap();
- }).detach();
+ });
let mut b = [0];
let mut s = TcpStream::connect(addr).unwrap();
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv().unwrap();
- }).detach();
+ });
let mut s = TcpStream::connect(addr).unwrap();
let s2 = s.clone();
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_timeout(Some(20));
}
}
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_read_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
rx.recv().unwrap();
assert_eq!(s.write(&[0]), Ok(()));
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
let s2 = s.clone();
Thread::spawn(move |:| {
let mut stream = stream;
tx.send(stream.read_to_end()).unwrap();
- }).detach();
+ });
}
None => tx.send(Ok(Vec::new())).unwrap()
}
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
// when we drop the TimerWatcher we're going to destroy the channel,
// which must wake up the task on the other end
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
timer.oneshot(Duration::milliseconds(1));
}
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
timer.sleep(Duration::milliseconds(1));
}
/// # fn long_running_task() {}
/// # fn calculate_the_answer() -> int { 42i }
///
-/// Thread::spawn(move|| { long_running_task(); tx1.send(()) }).detach();
-/// Thread::spawn(move|| { tx2.send(calculate_the_answer()) }).detach();
+/// 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"),
#[test]
fn test_null_byte() {
use thread::Thread;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new(b"foo/bar\0")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").set_filename(b"f\0o")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").push(b"f\0o");
}).join();
assert!(result.is_err());
#[test]
fn test_null_byte() {
use thread::Thread;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new(b"foo/bar\0")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").set_filename(b"f\0o")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move || {
+ let result = Thread::scoped(move || {
Path::new("test").push(b"f\0o");
}).join();
assert!(result.is_err());
r.fill_bytes(&mut v);
Thread::yield_now();
}
- }).detach();
+ });
}
// start all the tasks
/// println!("before wait");
/// c.wait();
/// println!("after wait");
-/// }).detach();
+/// });
/// }
/// ```
#[stable]
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(c.wait().is_leader()).unwrap();
- }).detach();
+ });
}
// At this point, all spawned tasks should be blocked,
/// let mut started = lock.lock().unwrap();
/// *started = true;
/// cvar.notify_one();
-/// }).detach();
+/// });
///
/// // wait for the thread to start up
/// let &(ref lock, ref cvar) = &*pair;
cnt = cond.wait(cnt).unwrap();
}
tx.send(()).unwrap();
- }).detach();
+ });
}
drop(tx);
Thread::spawn(move |:| {
// Don't panic if the other end has hung up
let _ = tx.send(blk());
- }).detach();
+ });
Future::from_receiver(rx)
}
//! let (tx, rx) = channel();
//! Thread::spawn(move|| {
//! tx.send(10i).unwrap();
-//! }).detach();
+//! });
//! assert_eq!(rx.recv().unwrap(), 10i);
//! ```
//!
//! let tx = tx.clone();
//! Thread::spawn(move|| {
//! tx.send(i).unwrap();
-//! }).detach()
+//! });
//! }
//!
//! for _ in range(0i, 10i) {
//! Thread::spawn(move|| {
//! // This will wait for the parent task to start receiving
//! tx.send(53).unwrap();
-//! }).detach();
+//! });
//! rx.recv().unwrap();
//! ```
//!
/// Thread::spawn(move|| {
/// # fn expensive_computation() {}
/// tx.send(expensive_computation()).unwrap();
-/// }).detach();
+/// });
///
/// // Do some useful work for awhile
///
/// Thread::spawn(move|| {
/// // this will block until the previous message has been received
/// tx.send(2i).unwrap();
-/// }).detach();
+/// });
///
/// assert_eq!(rx.recv().unwrap(), 1i);
/// assert_eq!(rx.recv().unwrap(), 2i);
#[test]
fn stress() {
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0u, 10000) { tx.send(1i).unwrap(); }
});
for _ in range(0u, 10000) {
static NTHREADS: uint = 8;
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0, AMT * NTHREADS) {
assert_eq!(rx.recv().unwrap(), 1);
}
let tx = tx.clone();
Thread::spawn(move|| {
for _ in range(0, AMT) { tx.send(1).unwrap(); }
- }).detach();
+ });
}
drop(tx);
t.join().ok().unwrap();
fn send_from_outside_runtime() {
let (tx1, rx1) = channel::<()>();
let (tx2, rx2) = channel::<int>();
- let t1 = Thread::spawn(move|| {
+ let t1 = Thread::scoped(move|| {
tx1.send(()).unwrap();
for _ in range(0i, 40) {
assert_eq!(rx2.recv().unwrap(), 1);
}
});
rx1.recv().unwrap();
- let t2 = Thread::spawn(move|| {
+ let t2 = Thread::scoped(move|| {
for _ in range(0i, 40) {
tx2.send(1).unwrap();
}
#[test]
fn recv_from_outside_runtime() {
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0i, 40) {
assert_eq!(rx.recv().unwrap(), 1);
}
fn no_runtime() {
let (tx1, rx1) = channel::<int>();
let (tx2, rx2) = channel::<int>();
- let t1 = Thread::spawn(move|| {
+ let t1 = Thread::scoped(move|| {
assert_eq!(rx1.recv().unwrap(), 1);
tx2.send(2).unwrap();
});
- let t2 = Thread::spawn(move|| {
+ let t2 = Thread::scoped(move|| {
tx1.send(1).unwrap();
assert_eq!(rx2.recv().unwrap(), 2);
});
#[test]
fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
let (tx, rx) = channel::<int>();
drop(tx);
rx.recv().unwrap();
let _t = Thread::spawn(move|| {
drop(tx);
});
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
assert!(rx.recv().unwrap() == box 10);
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
drop(rx);
});
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
tx.send(1).unwrap();
}).join();
}
for _ in range(0, stress_factor()) {
let (tx, rx) = channel::<int>();
Thread::spawn(move|| {
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
rx.recv().unwrap();
}).join();
assert!(res.is_err());
- }).detach();
+ });
let _t = Thread::spawn(move|| {
Thread::spawn(move|| {
drop(tx);
- }).detach();
+ });
});
}
}
Thread::spawn(move|| {
tx.send(box i).unwrap();
send(tx, i + 1);
- }).detach();
+ });
}
fn recv(rx: Receiver<Box<int>>, i: int) {
Thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1);
- }).detach();
+ });
}
}
}
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
}
for _ in range(0, total) {
Thread::spawn(move|| {
tx.send(1).unwrap();
tx.send(1).unwrap();
- }).detach();
+ });
while rx.recv().is_ok() {}
}
let (tx, rx) = sync_channel::<int>(0);
Thread::spawn(move|| {
for _ in range(0u, 10000) { tx.send(1).unwrap(); }
- }).detach();
+ });
for _ in range(0u, 10000) {
assert_eq!(rx.recv().unwrap(), 1);
}
_ => {}
}
dtx.send(()).unwrap();
- }).detach();
+ });
for _ in range(0, NTHREADS) {
let tx = tx.clone();
Thread::spawn(move|| {
for _ in range(0, AMT) { tx.send(1).unwrap(); }
- }).detach();
+ });
}
drop(tx);
drx.recv().unwrap();
#[test]
fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
let (tx, rx) = sync_channel::<int>(0);
drop(tx);
rx.recv().unwrap();
let _t = Thread::spawn(move|| {
drop(tx);
});
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
assert!(rx.recv().unwrap() == box 10);
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
drop(rx);
});
- let _ = Thread::spawn(move || {
+ let _ = Thread::scoped(move || {
tx.send(1).unwrap();
}).join();
}
for _ in range(0, stress_factor()) {
let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| {
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
rx.recv().unwrap();
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
Thread::spawn(move|| {
drop(tx);
- }).detach();
+ });
});
}
}
Thread::spawn(move|| {
tx.send(box i).unwrap();
send(tx, i + 1);
- }).detach();
+ });
}
fn recv(rx: Receiver<Box<int>>, i: int) {
Thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1);
- }).detach();
+ });
}
}
}
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
}
for _ in range(0, total) {
q.push(i);
}
tx.send(()).unwrap();
- }).detach();
+ });
}
let mut i = 0u;
/// tx.send(()).unwrap();
/// }
/// // the lock is unlocked here when `data` goes out of scope.
-/// }).detach();
+/// });
/// }
///
/// rx.recv().unwrap();
/// let lock = Arc::new(Mutex::new(0u));
/// let lock2 = lock.clone();
///
-/// let _ = Thread::spawn(move || -> () {
+/// let _ = Thread::scoped(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();
let (tx, rx) = channel();
for _ in range(0, K) {
let tx2 = tx.clone();
- Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
+ Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
let tx2 = tx.clone();
- Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
+ Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
}
drop(tx);
fn test_mutex_arc_poison() {
let arc = Arc::new(Mutex::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
let lock = arc2.lock().unwrap();
assert_eq!(*lock, 2);
}).join();
fn test_mutex_arc_access_in_unwind() {
let arc = Arc::new(Mutex::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| -> () {
+ let _ = Thread::scoped(move|| -> () {
struct Unwinder {
i: Arc<Mutex<int>>,
}
assert!(run);
}
tx.send(()).unwrap();
- }).detach();
+ });
}
unsafe {
}
}
drop(tx);
- }).detach();
+ });
}
drop(tx);
let _ = rx.recv();
fn test_rw_arc_poison_wr() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.write().unwrap();
panic!();
}).join();
fn test_rw_arc_poison_ww() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.write().unwrap();
panic!();
}).join();
fn test_rw_arc_no_poison_rr() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.read().unwrap();
panic!();
}).join();
fn test_rw_arc_no_poison_rw() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.read().unwrap();
panic!()
}).join();
*lock = tmp + 1;
}
tx.send(()).unwrap();
- }).detach();
+ });
// Readers try to catch the writer in the act
let mut children = Vec::new();
for _ in range(0u, 5) {
let arc3 = arc.clone();
- children.push(Thread::spawn(move|| {
+ children.push(Thread::scoped(move|| {
let lock = arc3.read().unwrap();
assert!(*lock >= 0);
}));
fn test_rw_arc_access_in_unwind() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| -> () {
+ let _ = Thread::scoped(move|| -> () {
struct Unwinder {
i: Arc<RwLock<int>>,
}
tx.send(()).unwrap();
drop(s2.access());
tx.send(()).unwrap();
- }).detach();
+ });
rx.recv().unwrap(); // wait for child to come alive
}
rx.recv().unwrap(); // wait for child to be done
}
sentinel.cancel();
- }).detach();
+ });
}
#[cfg(test)]
let _g = self.lock.lock().unwrap();
*self.shutdown.get() = true;
self.cond.notify_one()
- }).detach();
+ });
rt::at_exit(move|:| { self.shutdown() });
*self.initialized.get() = true;
inner: Arc<Inner>,
}
-#[stable]
-unsafe impl Sync for Thread {}
-
impl Thread {
// Used only internally to construct a thread object without spawning
fn new(name: Option<String>) -> Thread {
#[test]
fn test_unnamed_thread() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
assert!(Thread::current().name().is_none());
}).join().map_err(|_| ()).unwrap();
}
#[test]
fn test_named_thread() {
- Builder::new().name("ada lovelace".to_string()).spawn(move|| {
+ Builder::new().name("ada lovelace".to_string()).scoped(move|| {
assert!(Thread::current().name().unwrap() == "ada lovelace".to_string());
}).join().map_err(|_| ()).unwrap();
}
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
rx.recv().unwrap();
}
#[test]
fn test_join_success() {
- match Thread::spawn(move|| -> String {
+ match Thread::scoped(move|| -> String {
"Success!".to_string()
}).join().as_ref().map(|s| s.as_slice()) {
result::Result::Ok("Success!") => (),
#[test]
fn test_join_panic() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!()
}).join() {
result::Result::Err(_) => (),
} else {
f(i - 1, tx);
}
- }).detach();
+ });
}
f(10, tx);
Thread::spawn(move|| {
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
- }).detach();
+ });
+ });
rx.recv().unwrap();
}
#[test]
fn test_avoid_copying_the_body_spawn() {
avoid_copying_the_body(|v| {
- Thread::spawn(move || v.invoke(())).detach();
+ Thread::spawn(move || v.invoke(()));
});
}
avoid_copying_the_body(|f| {
Thread::spawn(move|| {
f.invoke(());
- }).detach();
+ });
})
}
#[test]
fn test_avoid_copying_the_body_join() {
avoid_copying_the_body(|f| {
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
f.invoke(())
}).join();
})
fn child_no(x: uint) -> Thunk {
return Thunk::new(move|| {
if x < GENERATIONS {
- Thread::spawn(move|| child_no(x+1).invoke(())).detach();
+ Thread::spawn(move|| child_no(x+1).invoke(()));
}
});
}
- Thread::spawn(|| child_no(0).invoke(())).detach();
+ Thread::spawn(|| child_no(0).invoke(()));
}
#[test]
fn test_simple_newsched_spawn() {
- Thread::spawn(move || {}).detach();
+ Thread::spawn(move || {});
}
#[test]
fn test_try_panic_message_static_str() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!("static string");
}).join() {
Err(e) => {
#[test]
fn test_try_panic_message_owned_str() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!("owned string".to_string());
}).join() {
Err(e) => {
#[test]
fn test_try_panic_message_any() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!(box 413u16 as Box<Any + Send>);
}).join() {
Err(e) => {
fn test_try_panic_message_unit_struct() {
struct Juju;
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!(Juju)
}).join() {
Err(ref e) if e.is::<Juju>() => {}
let mut reader = ChanReader::new(rx);
let stdout = ChanWriter::new(tx);
- let r = Builder::new().stdout(box stdout as Box<Writer + Send>).spawn(move|| {
+ let r = Builder::new().stdout(box stdout as Box<Writer + Send>).scoped(move|| {
print!("Hello, world!");
}).join();
assert!(r.is_ok());
/// assert_eq!(*f.borrow(), 1);
/// *f.borrow_mut() = 3;
/// });
-/// }).detach();
+/// });
///
/// // we retain our original value of 2 despite the child thread
/// FOO.with(|f| {
}
thread_local!(static FOO: Foo = foo());
- Thread::spawn(|| {
+ Thread::scoped(|| {
assert!(FOO.state() == State::Uninitialized);
FOO.with(|_| {
assert!(FOO.state() == State::Valid);
}
}
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
drop(S1);
}).join().ok().unwrap();
}
}
}
- Thread::spawn(move|| unsafe {
+ Thread::scoped(move|| unsafe {
K1.with(|s| *s.get() = Some(S1));
}).join().ok().unwrap();
}
cfg = cfg.stderr(box stderr as Box<Writer + Send>);
}
- let result_guard = cfg.spawn(move || { testfn.invoke(()) });
+ let result_guard = cfg.scoped(move || { testfn.invoke(()) });
let stdout = reader.read_to_end().unwrap().into_iter().collect();
let test_result = calc_result(&desc, result_guard.join());
monitor_ch.send((desc.clone(), test_result, stdout)).unwrap();
- }).detach();
+ });
}
match testfn {
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(x.clone());
- }).detach();
+ });
rx
}
let mut worker_results = Vec::new();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes)).unwrap();
}
Thread::spawn(move|| {
server(&from_parent, &to_parent);
- }).detach();
+ });
for r in worker_results.into_iter() {
let _ = r.join();
let mut worker_results = Vec::new();
let from_parent = if workers == 1 {
let (to_child, from_parent) = channel();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes));
let (to_child, from_parent) = channel();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes));
};
Thread::spawn(move|| {
server(&from_parent, &to_parent);
- }).detach();
+ });
for r in worker_results.into_iter() {
let _ = r.join();
// Create a channel: B->A
let (btx, brx) = channel();
- let guard_a = Thread::spawn(move|| {
+ let guard_a = Thread::scoped(move|| {
let (tx, rx) = (atx, brx);
for _ in range(0, n) {
tx.send(()).unwrap();
}
});
- let guard_b = Thread::spawn(move|| {
+ let guard_b = Thread::scoped(move|| {
let (tx, rx) = (btx, arx);
for _ in range(0, n) {
rx.recv().unwrap();
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(parfib(n-1));
- }).detach();
+ });
let m2 = parfib(n-2);
return (rx.recv().unwrap() + m2);
}
let mut messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
use std::num::Int;
let iterations = 2i.pow((max_depth - depth + min_depth) as uint);
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut chk = 0;
for i in range(1, iterations + 1) {
let arena = TypedArena::new();
from_rendezvous,
to_rendezvous,
to_rendezvous_log);
- }).detach();
+ });
to_creature
}).collect();
for (i, j) in range(0, N).zip(iter::count(0, k)) {
let max = cmp::min(j+k, perm.max());
- futures.push(Thread::spawn(move|| {
+ futures.push(Thread::scoped(move|| {
work(perm, j as uint, max as uint)
}))
}
Thread::spawn(move|| {
make_sequence_processor(sz, &from_parent, &to_parent_);
- }).detach();
+ });
to_child
}).collect::<Vec<Sender<Vec<u8> >> >();
let nb_freqs: Vec<_> = range(1u, 3).map(|i| {
let input = input.clone();
- (i, Thread::spawn(move|| generate_frequencies(input.as_slice(), i)))
+ (i, Thread::scoped(move|| generate_frequencies(input.as_slice(), i)))
}).collect();
let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| {
let input = input.clone();
- Thread::spawn(move|| generate_frequencies(input.as_slice(), occ.len()))
+ Thread::scoped(move|| generate_frequencies(input.as_slice(), occ.len()))
}).collect();
for (i, freq) in nb_freqs.into_iter() {
let mut precalc_i = Vec::with_capacity(h);
let precalc_futures = range(0, WORKERS).map(|i| {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut rs = Vec::with_capacity(w / WORKERS);
let mut is = Vec::with_capacity(w / WORKERS);
let vec_init_r = arc_init_r.clone();
let vec_init_i = arc_init_i.clone();
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8);
let init_r_slice = vec_init_r.as_slice();
let mut data = Data::new();
search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data);
tx.send(data).unwrap();
- }).detach();
+ });
}
// collecting the results
} else {
let (tx1, rx) = channel();
let tx2 = tx1.clone();
- Thread::spawn(move|| pfib(&tx2, n - 1)).detach();
+ Thread::spawn(move|| pfib(&tx2, n - 1));
let tx2 = tx1.clone();
- Thread::spawn(move|| pfib(&tx2, n - 2)).detach();
+ 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) ).detach();
+ Thread::spawn(move|| pfib(&tx, n) );
rx.recv().unwrap()
}
fn stress(num_tasks: int) {
let mut results = Vec::new();
for i in range(0, num_tasks) {
- results.push(Thread::spawn(move|| {
+ results.push(Thread::scoped(move|| {
stress_task(i);
}));
}
tx.send(token);
for i in range(2, n_tasks + 1) {
let (tx, next_rx) = channel();
- Thread::spawn(move|| roundtrip(i, tx, rx)).detach();
+ Thread::spawn(move|| roundtrip(i, tx, rx));
rx = next_rx;
}
- Thread::spawn(move|| roundtrip(1, tx, rx)).detach();
+ Thread::spawn(move|| roundtrip(1, tx, rx));
}
fn roundtrip(id: int, tx: Sender<int>, rx: Receiver<int>) {
fn run(repeat: int, depth: int) {
for _ in range(0, repeat) {
let dur = Duration::span(|| {
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
recurse_or_panic(depth, None)
}).join();
});
} else {
tx.send(()).unwrap()
}
- }).detach();
+ });
}
fn main() {
fn f(n: uint) {
let mut i = 0u;
while i < n {
- let _ = Thread::spawn(move|| g()).join();
+ let _ = Thread::scoped(move|| g()).join();
i += 1u;
}
}
};
let n = args[1].parse().unwrap();
let mut i = 0u;
- while i < n { Thread::spawn(move|| f(n) ).detach(); i += 1u; }
+ while i < n { Thread::spawn(move|| f(n) ); i += 1u; }
}
use std::thread::Thread;
fn main() {
- let r: Result<int,_> = Thread::spawn(move|| {
+ let r: Result<int,_> = Thread::scoped(move|| {
panic!("test");
1i
}).join();
use std::thread::Builder;
fn main() {
- let r: Result<int,_> = Builder::new().name("owned name".to_string()).spawn(move|| {
+ let r: Result<int,_> = Builder::new().name("owned name".to_string()).scoped(move|| {
panic!("test");
1i
}).join();
fn main() {
// the purpose of this test is to make sure that task::spawn()
// works when provided with a bare function:
- let r = Thread::spawn(startfn).join();
+ let r = Thread::scoped(startfn).join();
if r.is_err() {
panic!()
}
}
fn main() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let _a = A;
lib::callback(|| panic!());
1i
}
pub fn main() {
- Thread::spawn(fails).join();
+ Thread::scoped(fails).join();
}
_ = rx2.recv() => unsafe { libc::exit(1) },
_ = rx1.recv() => {}
}
- }).detach();
+ });
match p.wait().unwrap() {
ExitStatus(..) => panic!("expected a signal"),
ExitSignal(..) => tx.send(()).unwrap(),
pub fn main() {
unsafe {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let i = &100i;
rust_dbg_call(callback, mem::transmute(i));
}).join();
-
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
for i in inputs.iter() {
let ctrl = ctrl.clone();
let i = i.clone();
- Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ).detach();
+ Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) );
}
}
use std::thread::Thread;
fn main() {
- Thread::spawn(move|| customtask()).join().ok().unwrap();
+ Thread::scoped(move|| customtask()).join().ok().unwrap();
}
fn customtask() {
fn main() {
let (tx, rx) = channel();
- let _t = Thread::spawn(move|| { helper(rx) }).detach();
+ let _t = Thread::spawn(move|| { helper(rx) });
let (snd, rcv) = channel::<int>();
for _ in range(1i, 100000i) {
snd.send(1i).unwrap();
// Check that both closures are capturing by value
assert_eq!(1, mem::size_of_val(&closure));
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let ok = closure;
}).join().ok().unwrap();
}
let mut stdin = std::io::stdin();
Thread::spawn(move|| {
let _ = stdin.read_to_end();
- }).detach();
+ });
}
static generations: uint = 1024+256+128+49;
fn spawn(f: Thunk) {
- Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(())).detach()
+ Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(()));
}
fn child_no(x: uint) -> Thunk {
tx.send("hello, world").unwrap();
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
println(rx.recv().unwrap());
}).join().ok().unwrap();
}
pub fn main() {
let (tx, rx) = channel::<&'static str>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
assert_eq!(rx.recv().unwrap(), "hello, world");
});
use std::thread::Thread;
fn main() {
- assert!(Thread::spawn(move|| int::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i8::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i16::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i32::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i64::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| 1i / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i8 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i16 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i32 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i64 / 0).join().is_err());
- assert!(Thread::spawn(move|| int::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i8::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i16::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i32::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i64::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| 1i % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i8 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i16 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i32 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i64 % 0).join().is_err());
+ assert!(Thread::scoped(move|| int::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i8::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| 1i / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i8 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i16 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i32 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i64 / 0).join().is_err());
+ assert!(Thread::scoped(move|| int::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i8::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| 1i % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i8 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i16 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i32 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i64 % 0).join().is_err());
}
Err(..) => break
}
}
- }).detach();
+ });
return port;
}
}
i = i + 1;
}
- }).detach();
+ });
return port;
}
}
}
}
-
}
pub fn main() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut f = Foo(Cell::new(0));
println!("{}", f);
let Foo(ref mut f) = f;
macro_rules! spawn {
($($code: tt)*) => {
- expr!(Thread::spawn(move|| {$($code)*}).detach())
+ expr!(Thread::spawn(move|| {$($code)*}))
}
}
}
fn main() {
- Thread::spawn(move|| -> () {
+ Thread::scoped(move|| -> () {
let _a = A;
panic!();
}).join().unwrap_err();
}
pub fn main() {
- let ret = Thread::spawn(move|| {
+ let ret = Thread::scoped(move|| {
let _a = A { b: B { foo: 3 } };
}).join();
assert!(ret.is_err());
unsafe { assert!(dropped); }
}
-
println!("{}", *three + n); // will copy x into the closure
assert_eq!(*three, 3);
};
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
test05_start(fn_to_send);
}).join().ok().unwrap();
}
}
fn main() {
- Thread::spawn(move|| { ::b::g() }).join().unwrap_err();
+ Thread::scoped(move|| { ::b::g() }).join().unwrap_err();
}
}
fn main() {
- let _ = Thread::spawn(move|| foo()).join();
+ let _ = Thread::scoped(move|| foo()).join();
unsafe { assert!(DTOR_COUNT == 2); }
}
}
fn main() {
- let _ = Thread::spawn(move|| foo()).join();
+ let _ = Thread::scoped(move|| foo()).join();
unsafe { assert!(DTOR_COUNT == 2); }
}
pub fn main() {
let (tx, _rx) = channel::<int>();
- let t = Thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
+ let t = Thread::scoped(move|| iotask(&tx, "localhost".to_string()) );
t.join().ok().unwrap();
}
use std::thread::Thread;
pub fn main() {
- Thread::spawn(move|| child(10)).join().ok().unwrap();
+ Thread::scoped(move|| child(10)).join().ok().unwrap();
}
fn child(i: int) { println!("{}", i); assert!((i == 10)); }
use std::thread::Thread;
pub fn main() {
- let t = Thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
+ let t = Thread::scoped(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
t.join().ok().unwrap();
}
pub fn main() {
let mut t = Builder::new();
- t.spawn(move|| ()).detach();
+ t.spawn(move|| ());
}
fn start() { println!("Started / Finished task."); }
fn test00() {
- let _ = Thread::spawn(move|| start() ).join();
+ let _ = Thread::scoped(move|| start() ).join();
println!("Completing.");
}
fn test00() {
let i: int = 0;
- let mut result = Thread::spawn(move|| {
+ let mut result = Thread::scoped(move|| {
start(i)
});
pub fn main() {
println!("Check that we don't deadlock.");
let (tx, rx) = channel();
- let _ = Thread::spawn(move|| { start(&tx, 0, 10) }).join();
+ let _ = Thread::scoped(move|| { start(&tx, 0, 10) }).join();
println!("Joined task");
}
while (i > 0) {
println!("{}", i);
let tx = tx.clone();
- Thread::spawn({let i = i; move|| { child(i, &tx) }}).detach();
+ Thread::spawn({let i = i; move|| { child(i, &tx) }});
i = i - 1;
}
}
pub fn main() {
- let _t = Thread::spawn(move|| f() ).join();
+ let _t = Thread::scoped(move|| f() ).join();
}
let mut results = Vec::new();
while i < number_of_tasks {
let tx = tx.clone();
- results.push(Thread::spawn({
+ results.push(Thread::scoped({
let i = i;
move|| {
test00_start(&tx, i, number_of_messages)
let (tx, rx) = channel();
let number_of_messages: int = 10;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
test00_start(&tx, number_of_messages);
});
let mut reader = ChanReader::new(rx);
let stderr = ChanWriter::new(tx);
- let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).spawn(move|| -> () {
+ let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).scoped(move|| -> () {
panic!("Hello, world!")
}).join();
assert!(res.is_err());
}
}
srv_tx.send(());
- }).detach();
+ });
}
for _ in range(0, N) {
let _s = TcpStream::connect(addr).unwrap();
}
cli_tx.send(());
- }).detach();
+ });
}
drop((cli_tx, srv_tx));
timer::sleep(Duration::milliseconds(30 * 1000));
println!("timed out!");
unsafe { libc::exit(1) }
- }).detach();
+ });
let (tx, rx) = channel();
Thread::spawn(move || -> () {
stream.read_byte();
stream.write(&[2]);
}
- }).detach();
+ });
let addr = rx.recv().unwrap();
let (tx, rx) = channel();
Err(e) => debug!("{}", e)
}
tx.send(()).unwrap();
- }).detach();
+ });
}
// Wait for all clients to exit, but don't wait for the server to exit. The
tx.send(tmp.path().clone()).unwrap();
panic!("panic to unwind past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
let path = rx.recv().unwrap();
assert!(!path.exists());
let _tmp = tmp;
panic!("panic to unwind past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
assert!(!path.exists());
let path;
let f = move|:| {
TempDir::new("test_rm_tempdir").unwrap()
};
- let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+ let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
path = tmp.path().clone();
assert!(path.exists());
}
tmp.close();
panic!("panic when unwinding past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
let path = rx.recv().unwrap();
assert!(!path.exists());
tmp.close();
panic!("panic when unwinding past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
assert!(!path.exists());
let path;
let f = move|:| {
TempDir::new("test_rm_tempdir").unwrap()
};
- let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+ let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
path = tmp.path().clone();
assert!(path.exists());
tmp.close();
}
pub fn dont_double_panic() {
- let r: Result<(), _> = Thread::spawn(move|| {
+ let r: Result<(), _> = Thread::scoped(move|| {
let tmpdir = TempDir::new("test").unwrap();
// Remove the temporary directory so that TempDir sees
// an error on drop
fn test_panic() {
fn f() { let _x: Box<int> = panic!(); }
- Thread::spawn(move|| f() ).join().err().unwrap();
+ Thread::scoped(move|| f() ).join().err().unwrap();
}
fn test_panic_indirect() {
fn f() -> ! { panic!(); }
fn g() { let _x: Box<int> = f(); }
- Thread::spawn(move|| g() ).join().err().unwrap();
+ Thread::scoped(move|| g() ).join().err().unwrap();
}
pub fn main() {
pub fn main() {
let mut i = 10;
while i > 0 {
- Thread::spawn({let i = i; move|| child(i)}).detach();
+ Thread::spawn({let i = i; move|| child(i)});
i = i - 1;
}
println!("main thread exiting");
let tx = tx.clone();
Thread::spawn(move|| {
child(&tx, i)
- }).detach();
+ });
expected += i;
}
}
pub fn main() {
- let x = Thread::spawn(move|| {
+ let x = Thread::scoped(move|| {
let _b = Foo;
}).join();
let v = main.clone();
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
let mut v = v;
let mut panic_countdown = panic_countdown;
v.as_mut_slice().sort_by(|a, b| {
use std::thread::Thread;
pub fn main() {
- let mut result = Thread::spawn(child);
+ let mut result = Thread::scoped(child);
println!("1");
Thread::yield_now();
println!("2");
use std::thread::Thread;
pub fn main() {
- let mut result = Thread::spawn(child);
+ let mut result = Thread::scoped(child);
println!("1");
Thread::yield_now();
result.join();
projects / rust.git / commitdiff