[async rust]

Article Sandbox

I will be running experiments in my own editor and will be saving the repo here.

My Experience With Rust

Rust is going to be my language for 2025. I've tinkered with a low-level networking framework called Zeke and I would like to continue working on that project.

Since working on Zeke, I've learned a bit more about programming on an interface level, and I think those skills will help a lot.

Rust has a few concepts that are challenging to me such as lifetimes and the borrow checker. But the number one thing which caused me challenges when writing zeke was multi-threaded rust.

If I had a good grapse on those concepts I would feel way more comfortable in the language. I think before I start diving into all the different multi-threaded types rust provides, I need to understand it's async model better.

Let's Get Rusty

Any time I think about rust, I think about Bodgen from Let's Get Rusty on youtube.

This video is where I am going to start.

Futures

The first big takeaway is that async functions in rust are just a facade over a function which returns a Future.

1async fn my_function() {
2    println!("I'm an async function!")
3}

is really just a fasade over:

1fn my_function() -> impl Future<Output = ()> {
2    println!("I'm an async function too!")
3}

I visited the docs and it looks like Future is a trait which can be polled to completetion.

When we use the await keyword, we are using a fasade over the poll method which is associated with the Future trait.

Tokio

Bodgen explains that Futures must be manually polled to completetion, which is cumbersom. But, that is why a runtime like tokio exists.

In a language like Javascript, Promises are handled by the language underneath the hood. But in Rust, the async runtime is not included in the std lib, so options like tokio have emerged.

I went ahead and added tokio to my cargo.toml:

1[package]
2name = "sandbox-async-rust"
3version = "0.1.0"
4edition = "2021"
5
6[dependencies]
7tokio = { version = "1", features = ["full"] }

Tokio Tasks

Tasks are used to make our code run concurrently. Tasks a green threads and are non-blocking similar to gorountines.

I discovered that tokio attempts to mimic the api provided by the Rust std lib for traditional threads. This makes it easy to swap between using tasks and traditional threads without a paradigm shift.

Futures Are Lazy

This is something to be noted. Futures are lazy in Rust which means we can collect our tasks and then call await on them later. If we do not await a task, then we do not experience any runtime cost for the task.

This is different than other languages that use the async/await syntax to handle asyncronous code.

Morphing Data Across Threads

After a bit of playing around, I found myself wondering how to make changes to data across multiple threads.

I ended up with something like this:

 1async fn morph_data_across_threads() {
 2    let str = String::from("I will be morphed!");
 3    let str_arc = Arc::new(Mutex::new(str));
 4    let mut handles = vec![];
 5    for i in 0..10 {
 6        let str_clone = Arc::clone(&str_arc);
 7        let task = tokio::spawn(async move {
 8            // lock the mutex to modify it
 9            let mut val = str_clone.lock().await;
10            val.push_str(&i.to_string());
11        });
12        handles.push(task);
13    }
14    for task in handles {
15        task.await.unwrap();
16    }
17    // retrieve the final value as str is expended
18    let final_str = str_arc.lock().await;
19    println!("{}", final_str);
20}

And with this we see the introduction of a few core types I think I'll need to study. I see Arc and Mutex. We are calling lock() and these are concepts I think I'll need to get a better grasp on.

The code runs, and I have a general understanding as to what is going on under the hood, but from what I understand about Rust, the way these types of constructs impact memory is important to get right.

Smart Pointers

After I started researching, I came across this video on smart pointers.

ChatGPT says: "A smart pointer is an object that acts like a pointer but provides additional features to manage the ownership, lifecycle, and memory of dynamically allocated resources. It is typically used in programming languages like C++ and Rust to handle memory safely and efficiently."

So, it looks like these constructs are called smart pointers. I am going to dig through them and do my best to get a surface level understanding of them.

Box

Box<T> enables us to dictate that some data should be stored on the heap instead of the stack.

We store things on the heap when we have no way of knowing the size of the data at compile time. You want to try and avoid storing things on the heap, but in certain situations it cannot be avoided.

The video points out Box<T> has 2 use-cases:

1. When we have a variable with a trait type which cannot be computer at compile time.
2. When we have a recursive data type whos fields include the struct it is derived from.

NOTE TO SELF: Go back and finish "async rust" when you have a better understanding of traits and lifetimes.