Rust, asynchronized: threads

Both async and threads features of Rust may be used separately. However, in this post we will be looking at the synergies of using async with threaded applications.

What are the pitfalls of threading?

Rust was built from the ground up with threaded memory sharing at top of mind. Use of threading in applications typically comes with a host of race conditions and possible memory corruption due to thread context-switching. In Rust, most of these problems are prevented through the use of linear-types in the type-checker.

How do I start a threaded program

The easiest way to get started with Rust async threads is to declare a function as async. Once a function is declared async, the .await syntax can be used inside of the function to declare that the function must wait for the previous future to end before itself may continue. If a thread is handed a future, then it will return a join handle with a future. If you want to force a thread to join into a parent then you will need to block on its join handle.

It should be warned that if a thread is spawned with an async function, then the async code will not be executed in the spawned thread, but instead after the future has been returned and awaited. This is a potential performance bottleneck that would prevent realizing the gains of asynchronous code across threads.

use std::{thread, time};
use futures::executor::block_on;
use futures::join;

async fn workload1() {
   let ten_millis = time::Duration::from_millis(10);
   thread::sleep(ten_millis);
   println!("working on 1 in {:?}", thread::current().id())
}
async fn workload2() {
   let five_millis = time::Duration::from_millis(5);
   thread::sleep(five_millis);
   println!("working on 2 in {:?}", thread::current().id())
}

async fn workload3() {
   let ten_millis = time::Duration::from_millis(10);
   thread::sleep(ten_millis);
   println!("working on 3 in {:?}", thread::current().id())
}
async fn workload4() {
   let five_millis = time::Duration::from_millis(5);
   thread::sleep(five_millis);
   println!("working on 4 in {:?}", thread::current().id())
}

fn main() {
   let t1 = thread::spawn(|| block_on(workload1()));
   let t2 = thread::spawn(|| block_on(workload2()));
   t1.join().unwrap();
   t2.join().unwrap();

   let t3 = thread::spawn(workload3);
   let t4 = thread::spawn(workload4);
   block_on(async { join!(t3.join().unwrap(), t4.join().unwrap()) });
}
Selfie

Andrew Johnson

Open Source:

Other Platforms

Published Books:

Books that I am reading:

Top Referrers:

  1. Google Search
  2. DuckDuckGo Search
  3. Sogou Search
  4. Bing Search
  5. Baidu Search

Tools:

Weblog: