// 使用一个命名函数，在某个不同的任务中输出一些深刻的文字

fn print_message() { println!("I am running in a different task!"); }

spawn(print_message);

// 使用`proc`表达式，在一个不同的任务中输出一些深刻的文字

// `proc`表达式的值会被计算成一个(匿名)被拥有的闭包。

// 那个闭包会在所创建的任务运行的时候调用`println!(...)`。

spawn(proc() println!("I am also running in a different task!") );

在 Rust 中，创建任务并没有什么特殊的：任务 并不是语言语义中的一个什么概念。而是， Rust 的类型系统提供 了用来实现安全的并发性的所有必要工具：尤其 是， 被拥有的类型 。语言 将实现细节 留给标准库来做。

spawn 函数 的类型签名是狠简单的： fn spawn(f: proc()) 。因为 它只接受 被拥有的闭包， 而被拥有的闭包中只包含被拥有的数据，所以， spawn 可以安全地将整个闭包和与它关联的状态移动到一个完全不同的任务中去执行。 就与任何其它的闭包一样，传递 给 spawn 的函数可以捕获周围环境中的数据，并且携带到其它的任务中去。

let child_task_number = generate_task_number();

spawn(proc() {

// 在远程任务中捕获它

println! ( "I am child number {}" , child_task_number);

});

spawn(proc() {

let result = some_expensive_computation();

tx.send(result);

});

some_other_expensive_computation();

let result = rx.recv();

让我们仔细研究一下这个示例。首先 ， let 语句创建 了一个用于 发送及接收整数的流（ let 语句 的左侧， 即 (tx, rx) ，是一个解构（ destructuring ） let 的例子： 这个模式将一个元组分割成两个组件 ）。

子任务会使用发送器来向亲代任务发送数据，亲代任务会使用接收器来等待并接收数据。下一条语句，创建了子代任务。

let result = some_expensive_computation();

tx.send(result);

});

注意 ，在创建任务闭包时， 就隐式地将 tx 转移 给子任务了：闭包捕获 了环境中的 tx 。 Sender 和 Receiver 都是可发送的类型，因此 可以被任务捕获，或者 在任务之间传递。 在这个示例中， 子任务进行了一项费时的计算，然后 将结果通过捕获 的频道发送回来。

最后，亲代任务自身也做了一些费时的计算，然后在接收器上等待子任务发来的结果：

let result = rx.recv();

由 channel 创建的 Sender 和 Receiver 二元对，使得妳可以在单个发送者和单个接收者之间高效地通信，但是 不允许多个发送者使用同一个 Sender 值， 也不允许多个接收者使用同一个 Receiver 值。那么 ，如果我们的示例代码中需要由多个任务同时计算多个结果的话，怎么搞？下面 这个程序的代码写得不对：

spawn(proc() {

tx.send(some_expensive_computation());

});

// 错误！前面的一个spawn语句已经拥有了发送器，

// 所以编译器不会允许再次捕获它

spawn(proc() {

tx.send(some_expensive_computation());

});

办法 还是有的，我们可以复制 tx ，这样就可以被多个发送者使用了。

for init_val in range(0u, 3) {

// 创建 一个新的频道把柄（ handle ）以向子任务发送信息

let child_tx = tx.clone();

spawn( proc () {

child_tx.send(some_expensive_computation(init_val));

});

}

let result = rx.recv() + rx.recv() + rx.recv();

复制 一个 Sender 的话，会产生针对同一个频道的一个新的把柄， 这样就允许多个任务向单个接收器发送数据了。 它会在内部升级这个频道，以支持此处 所需的功能， 这就意味着， 未被复制的频道呢， 可以避免用于处理多个发送者所需的开销。但是 这个事实不会影响到对于频道的使用：升级过程是透明的。

注意 ， 以上这个复制的示例是比较牵强的，因为 妳可以直接使用三对 Sender ，但是 ，这个示例只是为了说明问题。 供妳参考，如果使用多个通信 流的话，可以写出以下示例代码。

// 创建一个端口向量，其中每个端口用于一个子任务

let rxs = Vec::from_fn(3, |init_val| {

let (tx, rx) = channel();

spawn( proc () {

tx.send(some_expensive_computation(init_val));

});

rx

});

// 等待每个端口，最后将它们的结果累加起来

let result = rxs.iter().fold(0, |accum, rx| accum + rx.recv() );

fn fib(n: u64) -> u64 {

// 费时 的计算，会返回一个 uint

12586269025

}

let mut delayed_fib = Future::spawn(proc() fib(50));

make_a_sandwich();

println!("fib(50) = {}", delayed_fib.get())

无论 fib(50) 需要计算多久， 在调用 future::spawn 时都会立即返回一个 future 对象。然后 ， 妳可以趁着 fib 仍然在计算的时候给自己做个三明治来吃吃。日后 ，可调用 get 来获取这个方法的执行结果。 这个调用会阻塞，直到那个值变为可用（ 也就是说 计算已经完 成 ）。注意 ， 这个未来对象必须是可变的， 这样，它就可以保存结果， 以便下次调用 get 时返回。

以下是另一个示例，展示的是如果使用未来对象来进行后台计算。这个负载会平均分配到各个CPU内核上。

let mut local_sum = 0f64 ;

for num in range(start* 100000 , (start+ 1 )* 100000 ) {

local_sum += (num as f64 + 1.0 ).powf(- 2.0 );

}

local_sum

}

fn main() {

let mut futures = Vec::from_fn( 1000 , |ind| Future::spawn( proc () { partial_sum(ind) }));

let mut final_res = 0f64 ;

for ft in futures.mut_iter()  {

final_res += ft.get();

}

println! ( "π^2/6 is not far from : {}" , final_res);

}

use std::sync::Arc;

fn pnorm(nums: &[f64], p: uint) -> f64 {

nums.iter().fold( 0.0 , |a, b| a + b.powf(p as f64)).powf( 1.0 / (p as f64))

}

fn main() {

let numbers = Vec::from_fn( 1000000 , |_| rand::random::<f64>());

let numbers_arc = Arc::new(numbers);

for num in range( 1u , 10 ) {

let task_numbers = numbers_arc.clone();

spawn( proc () {

println! ( "{}-norm = {}" , num, pnorm(task_numbers.as_slice(), num));

});

}

}

函数 pnorm 对该向量进行一个简单的计算（ 它计算每个元素的幂，以给定的参数为指数，然后再计算这个值的幂的倒数，最后将所有结果相加 ）。 该向量的自动引用计数对象是由下面这行代码创建的

并且，每个任务都会捕获它的一个唯一的副本。这个过程只会复制包装器本身，而不会复制内容。在任务的代码体中，所捕获的自动引用计数对象可被当作是对于底层向量的一个不可变的引用，就像它是一个局部变量一样。

spawn(proc() {

// 捕获task_numbers并且使用 它，就好像它就是底层的向量一样

println! ( "{}-norm = {}" , num, pnorm(task_numbers.as_slice(), num));

});

arc 模块 中还实现了对于可变数据的自动引用计数功能，在此不赘述。

if some_condition() {

calculate_result()

} else {

fail! ( "oops!" );

}

});

assert!(result.is_err());

fn stringifier(channel: &DuplexStream<String, uint>) {

let mut value: uint;

loop {

value = channel.recv();

channel.send(value.to_str());

if value == 0 { break ; }

}

}

DuplexStream 的实现支持同时发送和接收。 stringifier 函数接受 一个 DuplexStream 作为参数， 它可以发送字符串 (第一 个类型参数 ) 及接收 uint 消息(第二 个类型参数 ) 。函数 体本身只是简单地循环，从频道中读取数据，然后回复结果。实际 的回复内容只是 所接收到的值的字符串版本， uint::to_str(value) 。

以下是亲代任务的代码：

let (from_child, to_child) = duplex();

spawn(proc() {

stringifier( & to_child);

});

from_child.send(22);

assert!(from_child.recv().as_slice() == "22");

from_child.send(23);

from_child.send(0);

assert!(from_child.recv().as_slice() == "23");

assert!(from_child.recv().as_slice() == "0");