A Practical Introduction to Concurrency in rust

Concurrency in Rust is like juggling multiple balls at once, where each ball represents a task running independently. Rust provides a powerful set of tools for managing concurrent tasks, as well as a type-safe ownership and borrowing system to prevent data races and other concurrency issues. With Rust, you can easily build high-performance, parallel programs that take full advantage of modern multicore processors. So grab your juggling balls and get ready to build some blazing-fast concurrent programs in Rust!

This article is intended as a gentle introduction to the world of concurrent programming in Rust, and I encourage readers to continue exploring the topic beyond what I'll cover here.

Let's get jugglin'

To install two Rust crates I've used in this example Reqwest and Tokio using the Cargo package manager, you can use the following command:

cargo add reqwest tokio --features=tokio/full

The Plot

Let's consider a simple example of an image downloader in Rust that does not use concurrency. Imagine that you want to download a large number of images from the internet and save them to disk.

That would look something like this 👇🏽

// Using tokio to allow calling download_image which is async
#[tokio::main]
async fn main() {

let urls = vec![
        "https://images.pexels.com/photos/14996713/pexels-photo-14996713.jpeg",
        "https://images.pexels.com/photos/15274265/pexels-photo-15274265.jpeg",
        "https://images.pexels.com/photos/14286464/pexels-photo-14286464.jpeg",
        "https://images.pexels.com/photos/15215418/pexels-photo-15215418.jpeg",
    ];

    let start = Instant::now();
    for url in urls {
        download_image(url).await
    }
    println!("Time elapsed {:?}", start.elapsed())
}

Here we have are using tokio to support

download_image() function implementation

async fn download_image(url: &str) {

/*
Extract the filename from the URL by finding the last occurrence of '/'
and taking the substring that follows it.

Eg: url = https://images.pexels.com/photos/14286464/pexels-photo-14286464.jpeg
will result in a filename that looks like => pexels-photo-14286464.jpeg
*/
    let path = Path::new(&url[url.rfind('/').unwrap() + 1..]);

    let response = reqwest::get(url).await.unwrap();

    if response.status().is_success() {

        let mut buffer = vec![];
        let mut content = Cursor::new(response.bytes().await.unwrap());

        match copy(&mut content, &mut buffer) {
            Ok(_) => {
                let mut file = File::create(path).unwrap();
                file.write_all(&buffer).unwrap();
            },
            Err(_) => println!("Something went wrong here"),
        }
    } else {

    println!("Something went terribly wrong")

    }
}

With the code that doesn't use concurrency, downloading only four(4) images can feel like watching paint dry. On my computer the task consistently takes more that 40 seconds to complete!. That's why we need to spice things up and add some concurrency to make it go faster than a cat chasing a laser pointer.