Concurrency — Threads, async & Tokio

Overview

Safe Rust will not compile a data race. The cost is markers and locks. OS threads run in parallel. Async tasks share a runtime you opt into. Tokio is the common runtime. It is not part of the language.

The JS/TS language hub is the host-loop habit. The Python language hub is the GIL and asyncio habit. Neither replaces Send or an explicit runtime.

Comparative

flowchart TB
  A["Step 1 Classify the work Ready"]
  B["Step 2 CPU-bound or I/O-bound Ready"]
  C["Step 3a std::thread or rayon - closure is Send + 'static, or use thread::scope Ready"]
  D["Step 3b async fn returns a lazy Future Ready"]
  E["Step 4 Runtime polls it - tokio::spawn needs Send + 'static Ready"]
  F["Step 5 Share state - Arc plus Mutex, or channels Ready"]
  G["Step 6 Drop lock guards before .await Ready"]
  X["Failure path - worker stalls move it to spawn_blocking Ready"]
  Y["Failure path - future is not Send, or deadlock Ready"]
  A -->|continues| B
  B -->|CPU| C
  B -->|many sockets, I/O| D
  D -->|continues| E
  E -->|continues| F
  F -->|continues| G
  E -->|blocking call inside async| X
  G -->|std MutexGuard held across .await| Y

Press Run. Snippets must be self-contained — no network, files, or native modules.

Rosetta — spawn work

A thread returns a join handle. The closure must be Send and 'static.

use std::thread;

fn main() {
    let handle = thread::spawn(|| 21 * 2);
    println!("{}", handle.join().unwrap());
}

An async task needs a runtime. The attribute is Tokio, not the language:

// #[tokio::main]
// async fn main() {
//     let v = async { 21 * 2 }.await;
//     println!("{v}");
// }

async function main() {
  const v = await Promise.resolve(21 * 2);
  console.log(v);
}
main();

import asyncio

async def main() -> None:
    v = await asyncio.sleep(0, result=21 * 2)
    print(v)

asyncio.run(main())

The TypeScript Promise is scheduled by calling main. The Python coroutine runs when asyncio.run drives it. The Rust future is inert until something polls it.

Rosetta — a channel

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || tx.send(7).unwrap());
    println!("{}", rx.recv().unwrap());
}

const pending = Promise.resolve(7);
pending.then((n) => console.log(n));

from queue import Queue
from threading import Thread

q: Queue[int] = Queue()
Thread(target=lambda: q.put(7)).start()
print(q.get())

Message passing keeps the owner of each value obvious. Shared mutation is the harder pattern.

Rosetta — shared state

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

fn main() {
    let n = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();
    for _ in 0..4 {
        let n = Arc::clone(&n);
        handles.push(thread::spawn(move || {
            *n.lock().unwrap() += 1;
        }));
    }
    for handle in handles {
        handle.join().unwrap();
    }
}

let n = 0;
n += 1;
console.log(n);

from threading import Lock, Thread

n = 0
lock = Lock()

def bump() -> None:
    global n
    with lock:
        n += 1

threads = [Thread(target=bump) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(n)

Rust requires a Mutex (or atomics) for shared mutation across threads, plus Arc when threads must be 'static (thread::spawn). std::thread::scope threads can borrow &Mutex from the stack with no Arc, because the scope joins them before it returns. JavaScript shared mutation usually stays on one thread. Python still needs the lock for a compound update.

Pitfalls if you arrived from JavaScript

1. Futures are lazy until awaited or spawned.
2. The runtime is a crate, not the language.
3. Do not await while a std::sync::Mutex guard is held.
4. spawn on a multi-thread runtime needs 'static + Send.
5. Cancellation is dropping the future.
6. Use spawn_blocking for sync or CPU work inside async.

Interview Q&A

Pitfalls

• A future that is built and dropped.
• CPU or blocking I/O on a Tokio worker.
• A std Mutex guard held across await.
• An Rc captured by a spawned task.
• Assuming async means parallel.

Go Deeper

• The Book — Fearless Concurrency
• Asynchronous Programming in Rust
• Tokio tutorial