Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec nec volutpat neque, non ullamcorper nunc. Nam nisi arcu, porttitor mattis placerat lacinia, condimentum in nulla. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla interdum ut sapien scelerisque ullamcorper. Aenean velit dolor, sollicitudin id dui ac, egestas molestie neque. Praesent ut semper massa, id lacinia felis. Fusce euismod blandit commodo. Curabitur congue, est sed lobortis euismod, enim nisi euismod nunc, ac hendrerit leo tortor sit amet magna. Maecenas aliquam, lectus non imperdiet finibus, ante massa tempor ligula, vel cursus metus justo sit amet tellus.
Fusce at arcu mollis, fermentum sapien fringilla, luctus urna. Maecenas venenatis risus eu rhoncus laoreet. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras fermentum purus nec ante aliquet elementum. Sed congue viverra tellus ut tincidunt. Aenean et finibus nunc. In ac elit sed turpis facilisis scelerisque ac in sem. Ut blandit enim facilisis, tincidunt tortor ut, iaculis augue. Morbi commodo faucibus gravida. Maecenas congue eu mi at rhoncus. Pellentesque et sollicitudin ipsum, vitae commodo orci.
use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread;
static NTHREADS: i32 = 3;
fn main() {
// Channels have two endpoints: the `Sender<T>` and the `Receiver<T>`,
// where `T` is the type of the message to be transferred
// (type annotation is superfluous)
let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();
let mut children = Vec::new();
for id in 0..NTHREADS {
// The sender endpoint can be copied
let thread_tx = tx.clone();
// Each thread will send its id via the channel
let child = thread::spawn(move || {
// The thread takes ownership over `thread_tx`
// Each thread queues a message in the channel
thread_tx.send(id).unwrap();
// Sending is a non-blocking operation, the thread will continue
// immediately after sending its message
println!("thread {} finished", id);
});
children.push(child);
}
// Here, all the messages are collected
let mut ids = Vec::with_capacity(NTHREADS as usize);
for _ in 0..NTHREADS {
// The `recv` method picks a message from the channel
// `recv` will block the current thread if there are no messages available
ids.push(rx.recv());
}
// Wait for the threads to complete any remaining work
for child in children {
child.join().expect("oops! the child thread panicked");
}
// Show the order in which the messages were sent
println!("{:?}", ids);
}Nulla mollis, purus ut interdum commodo, leo lorem molestie ex, sit amet tempor odio nisl sit amet ante. Cras sed augue ligula. Aliquam nulla magna, molestie sed efficitur nec, interdum vitae neque. Phasellus suscipit ex vel magna consequat fringilla. Proin nec imperdiet est. Ut lobortis mi libero, in faucibus ligula dictum a. Mauris semper tincidunt neque, id scelerisque lectus sollicitudin ac. Praesent arcu odio, luctus at enim a, porttitor laoreet ex. Suspendisse potenti. Ut sit amet arcu nisl. Suspendisse volutpat commodo ligula, vitae facilisis justo varius in.
Morbi vitae luctus nisi, id pharetra ipsum. Proin placerat sem vel quam vestibulum hendrerit. Maecenas at efficitur metus, sit amet pulvinar dolor. Vestibulum ligula nulla, iaculis ut lacus in, sollicitudin tincidunt neque. Ut eleifend aliquet dapibus. Suspendisse dictum justo nibh, vel volutpat est fermentum vitae. Curabitur facilisis convallis arcu, vitae tempor nibh mattis non. Sed a purus id est gravida faucibus porta sit amet eros. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Maecenas sed tortor at dolor imperdiet tincidunt.
Comments are closed.