Несколько отправителей в канал в Rust

Один приемник может принимать данные от нескольких отправителей. Копия отправителя ссылается на ту же очередь, что и оригинал, и увеличивает счет живых отправителей. Пока хотя бы одна такая копия существует, очередь принимает новые значения.

Запустим два потока: каждый получит свой отправитель и положит число в общую очередь:

use std::sync::mpsc;
use std::thread;

fn main() {
	let (tx, rx) = mpsc::channel();
	let tx_two = tx.clone();
	let job_one = thread::spawn(move || {
		match tx.send(10) {
			Ok(()) => {}
			Err(_) => {}
		}
	});
	let job_two = thread::spawn(move || {
		match tx_two.send(20) {
			Ok(()) => {}
			Err(_) => {}
		}
	});
	match job_one.join() {
		Ok(()) => {}
		Err(_) => {}
	}
	match job_two.join() {
		Ok(()) => {}
		Err(_) => {}
	}
	match rx.recv() {
		Ok(v) => println!("a {}", v),
		Err(_) => {}
	}
	match rx.recv() {
		Ok(v) => println!("b {}", v),
		Err(_) => {}
	}
}

Порядок строк a и b может меняться от запуска к запуску: потоки работают параллельно. Главное, что оба числа приходят в один приемник.

После завершения потоков отправители исчезают сами. Прочитаем очередь до ошибки приема:

use std::sync::mpsc;
use std::thread;

fn main() {
	let (tx, rx) = mpsc::channel();
	let extra = tx.clone();
	let job_a = thread::spawn(move || {
		match tx.send(1) {
			Ok(()) => {}
			Err(_) => {}
		}
	});
	let job_b = thread::spawn(move || {
		match extra.send(2) {
			Ok(()) => {}
			Err(_) => {}
		}
	});
	match job_a.join() {
		Ok(()) => {}
		Err(_) => {}
	}
	match job_b.join() {
		Ok(()) => {}
		Err(_) => {}
	}
	loop {
		match rx.recv() {
			Ok(v) => println!("{}", v),
			Err(_) => {
				println!("stop");
				break;
			}
		}
	}
}

Дано число:

let num = 4;

Создайте очередь, сделайте копию отправителя и передайте число из main с оригинала, а затем с копии. Дважды примите и выведите оба значения.

Даны числа:

let num1 = 7;
let num2 = 8;

Запустите два потока с разными копиями отправителя, положите в очередь эти числа и примите оба на одном приемнике.

Скажите, зачем перед запуском потоков делают копию отправителя, а не передают одну переменную в оба потока.