rust_threadpool_executor.rs

use std::sync::{Arc, Mutex};
use tokio;

fn main() -> Result<(), Box<dyn std::error::Error>> {
	println!("Starting...");

	println!("===== Direct Execution ===");
	println!("Got {} from Task 1", task1());
	println!("Got {} from Task 2", task2());
	println!("Got {} from Task 3", task3());
	println!("Got {} from Task 4", task4(832476));

	println!("\n\n===== Tokio Thread Pool With 2 Worker Threads ===");
	// tokio crate
	use tokio::runtime;
	let rt  = runtime::Builder::new_multi_thread()
		.worker_threads(2)
		.build()?;

	let arc1: Arc<Mutex<Option::<f64>>> = Arc::new(Mutex::new(None));
	let arc1b = arc1.clone();
	let arc2: Arc<Mutex<Option::<i32>>> = Arc::new(Mutex::new(None));
	let arc2b = arc2.clone();
	let arc3: Arc<Mutex<Option::<String>>> = Arc::new(Mutex::new(None));
	let arc3b = arc3.clone();
	let arc4: Arc<Mutex<Option::<f64>>> = Arc::new(Mutex::new(None));
	let arc4b = arc4.clone();
	// Spawn the root task
	rt.block_on(async move {
		let future1 = tokio::spawn(async {task1()});
		let future2 = tokio::spawn(async {task2()});
		let future3 = tokio::spawn(async {task3()});
		let future4 = tokio::spawn(async {task4(832476)});

		// show results
		//println!("Got {:?} from Task 1", future1.await);
		// println!("Got {:?} from Task 2", future2.await);
		// println!("Got {:?} from Task 3", future3.await);
		// println!("Got {:?} from Task 4", future4.await);
		*arc1b.lock().unwrap() = Some(future1.await.unwrap());
		*arc2b.lock().unwrap() = Some(future2.await.unwrap());
		*arc3b.lock().unwrap() = Some(future3.await.unwrap());
		*arc4b.lock().unwrap() = Some(future4.await.unwrap());
	});
	println!("Got {} from Task 1", arc1.lock().unwrap().clone().unwrap());
	println!("Got {} from Task 2", arc2.lock().unwrap().clone().unwrap());
	println!("Got {} from Task 3", arc3.lock().unwrap().clone().unwrap());
	println!("Got {} from Task 4", arc4.lock().unwrap().clone().unwrap());


	println!("...Done!");
	Ok(())
}

fn task1() -> f64 {
	println!("Task 1...");
	let mut x: f64 = 2.01;
	for _ in 0..100000000 {
		x = x.sqrt()+x;
	}
	println!("Task 1 result: {}", x);
	println!("...Task 1 done.");
	return x;
}

fn task2() -> i32 {
	println!("Task 2...");
	let mut x: i32 = 1;
	let mut y: i32 = 1;
	for _ in 0..100000000 {
		let t = y;
		y = x.wrapping_add(y);
		x = t;
	}
	println!("Task 2 result: {}", y);
	println!("...Task 2 done.");
	return y;
}

fn task3() -> String {
	println!("Task 3...");
	let mut s = String::from("abcdefghijklmnopqrstuvwxyz");
	for _ in 0..1000000 {
		s = s.replace("def", "y");
		s = s.replace("abc", "x");
		s = s.replace("ghi", "z");
		s = s.replace("zyx", "xyz");
		s = s.replace("xyz", "abcdefghi");
	}
	println!("Task 3 result: {}", s);
	println!("...Task 3 done.");
	return s;
}

fn task4(i: i32) -> f64 {
	println!("Task 4...");
	let mut x = 1.;
	for n in 0..1000000 {
		x = x + i as f64 - n as f64;
	}
	println!("Task 4 result: {}", x);
	println!("...Task 4 done.");
	return x;
}