It's been a while since I haven't post anything here, been busy with work, school, family and life in general. But I'd say learning has been great recently, learning deeper into system programming and also backend programming at the same time, this really opens up my eyes to a lot more of things that I didn't know about. Also this year I gave myself a goal to start contributing to open source, specifically open source projects that are written in Rust. I've been learning Rust for a while now, and I think I'm ready to start contributing, whats the best way to learn than to actually do it, right? But this post is not about my journey to open source, it's about threading in Rust. It will be a very short post explaining the basics of threading in Rust.

So the other day I was practing a problem Compute Spiral Order Traversal of a Matrix and I thought, if the given matrix is large, it would be better to compute the spiral order traversal in parallel. So I thought of using threads to do that. I've never used threads in Rust before, so I thought it would be a good opportunity to learn it.

What is threading?

In computer science, threading is a technique that allows multiple threads of execution to run simultaneously within a single process. Modern computers have multiple cores, and threading allows us to take advantage of these cores to run multiple tasks concurrently. This helps with heavy computational tasks, I/O bound tasks, and tasks that can be parallelized. I won't get into the details here, but you can find a great explanation of threading here.

Real world use case

Let's say you have an drawing application, and you select a tool to draw a circle. When you start drawing the circle, the application starts to compute the points of the circle and draw it on the screen. Now if your application is only single threaded, the application will freeze until the circle is drawn. This is because the application is busy computing the points of the circle and can't do anything else. But if you use threading, you can start a new thread to compute the points of the circle, and the main thread can continue to do other things like handling user input, updating the screen, etc. This way the application won't freeze and the user can continue to interact with the application.

The problem

For simple illustrating purposes, let's say we want to generate a large matrix in our application which will be used for some heavy computation. We want to generate this matrix in parallel using threads to take advantage of multiple cores in the CPU. While our matrix is being generated we can do some other work in the main thread, but let's do this first without threading.

Consider the following code:

rust
fn generate_large_matrix(rows: usize, cols: usize) -> Vec<Vec<usize>> {
    println!("Generating large matrix...");

    let mut matrix: Vec<Vec<usize>> = Vec::with_capacity(rows * cols);
    let mut count = 1;

    for _ in 0..rows {
        let mut row = Vec::with_capacity(cols);
        for _ in 0..cols {
            row.push(count);
            count += 1;
        }
        matrix.push(row);
    }

    matrix
}

Here I just implemented a simple function to generate a matrix of size rows x cols and filled it with numbers starting from 1. And yes you can generate a large matrix better than this using iterators or some other methods, but this is just for demonstration purposes.

Now we can use this in our main function to generate a large matrix.

rust
fn main() {
    generate_large_matrix(20_000, 20_000);
    do_some_other_work(); 
}

fn do_some_other_work() {
    println!("Doing some other work");
}

I also added a function do_some_other_work() which just prints Doing some other work.

Now if cargo run this code, you will see that Generating large matrix... will be printed first and then Doing some other work will be printed. This is because the main thread is blocked until generate_large_matrix() is done.

If the matrix is large, it will take some time to generate, and the user will see the application freeze until the matrix is generated. Now imagine your whole application is blocked because of this, this is where threading comes in.

Threading in Rust

First we need to spawn a new thread using std::thread::spawn() function. This function takes a closure as an argument which contains the code that will run in the new thread. The spawn method returns a JoinHandle so that we can keep track of the progress of the thread that we spawned. We then use the join method on the JoinHandle which will block the current thread until the thread we spawned is finished. If you have multiple threads running you can use the is_finished method on the JoinHandle to check if the thread is finished or not, but for now we will just use join.

rust
use std::thread::spawn;

fn main() {
    let handle = spawn(|| {
        generate_large_matrix(20_000, 20_000);
    });

    do_some_other_work(); 
    handle.join().unwrap();
}

If you do cargo run now you can see that Doing some other work will be printed before the matrix is generated. As you can see from the gif below, the main thread is not blocked and can do other work while the matrix is being generated in the new thread. Also there are 2 threads running, one is the main thread and the other is the thread we spawned.

Conclusion

In this post I shared the basics of threading in Rust, what is it and how I learned it. I showed you a simple example of how to use threading in Rust to generate a large matrix in another thread while the main thread does some other work. In this context do_some_other_work() is a simple println! statement, but in a real application it could be some other heavy computation or I/O bound task. In that case they may compete for CPU time, so it's better to create more advance threading work than this one, I will probably write a blog post about that after I learn about it. For now I hope you understand the basics of threading in Rust.