ภาพรวม Concurrency

Concurrency ใน TypeScript vs Rust

JavaScript ทำงานบน single thread เพียง thread เดียว Event loop ประมวลผลทีละ task แล้วมอบงาน I/O ให้ระบบปฏิบัติการจัดการต่อ

Concurrency ใน JS เป็นแบบ cooperative: โค้ดของคุณยอมคืน control เมื่อถึง await แล้ว event loop จึงหยิบ callback ตัวถัดไปมาทำงาน ผลคือไม่มีอะไรรันแบบ parallel จริง ๆ ภายใน JS process เดียว ยกเว้นจะเปิด Web Worker ที่เป็นกระบวนการแยกที่คุยกันผ่าน postMessage เท่านั้น

Rust ใช้แนวทางที่ต่างออกไปสิ้นเชิง คุณได้ OS thread จริง ตั้งแต่ต้น ได้ระบบ async/await ที่รันบน user-space runtime (Tokio คือตัวเลือกมาตรฐาน) และได้ compiler ที่ กัน data race แบบ static ตั้งแต่ compile time ทาง Rust เรียกสิ่งนี้ว่า fearless concurrency — คุณเขียนโค้ด concurrent ได้เต็มที่ แล้ว compiler จะปฏิเสธการ compile โปรแกรมที่มี data-race bug

สองโมเดล concurrency ใน Rust

โมเดล	Primitive ใน Rust	คู่เทียบใน JS
OS threads (ทำงานแบบ parallel บน CPU)	`std::thread::spawn`	Web Workers (จำกัด)
Async I/O (tasks จำนวนมาก, thread pool เดียว)	`async`/`await` + Tokio	`Promise` / `async`/`await`
Shared mutable state (ข้าม threads)	`Arc<Mutex<T>>`	`SharedArrayBuffer` + `Atomics`
Message passing (ข้าม threads)	`std::sync::mpsc`	`worker.postMessage`

ทำไมถึงเรียกว่า “fearless”?

ระบบ ownership และ type ของ Rust บังคับกฎสองข้อ ณ compile time:

ค่าหนึ่งค่าสามารถมี ผู้อ่านหลายคน หรือ ผู้เขียนหนึ่งคน — ไม่ใช่ทั้งคู่พร้อมกัน
ข้อมูลที่แชร์ข้าม threads ต้อง implement marker traits Send และ Sync ซึ่ง compiler ตรวจสอบให้อัตโนมัติ

ถ้าคุณพยายามแชร์ &mut T ดิบๆ ข้าม threads โปรแกรม จะ compile ไม่ผ่าน ไม่มี runtime lock ไม่มีการ corrupt แบบเงียบๆ — bug ถูกจับก่อนโค้ดจะรัน

// JavaScript: single-threaded, concurrency via event loop
async function fetchAll(urls: string[]): Promise<string[]> {
  // All fetches start "in parallel" (concurrent I/O)
  // but JS code itself runs on one thread
  return Promise.all(urls.map(url => fetch(url).then(r => r.text())));
}

// Web Worker for CPU-bound parallelism (separate process)
const worker = new Worker('./worker.js');
worker.postMessage({ data: [1, 2, 3] });
worker.onmessage = (e) => console.log(e.data);

use std::thread;

fn main() {
    // Real OS thread — runs truly in parallel on another CPU core
    let h1 = thread::spawn(|| "fearless");
    let h2 = thread::spawn(|| "concurrency");

    // join() waits for the thread and returns its result
    let r1 = h1.join().unwrap();
    let r2 = h2.join().unwrap();
    println!("{r1} {r2}"); // fearless concurrency
}

ลองรันเลย

Open in Rust Playground

use std::thread;

fn main() {
    let h1 = thread::spawn(|| "fearless");
    let h2 = thread::spawn(|| "concurrency");
    let r1 = h1.join().unwrap();
    let r2 = h2.join().unwrap();
    println!("{r1} {r2}");
}

🟦 Fearless concurrency — ความปลอดภัยระดับ compile time

โมเดล concurrency ของ JavaScript ป้องกัน data race โดยธรรมชาติ — มี thread เดียว ดังนั้นสองส่วนของโค้ดจึงไม่มีทางทำงานพร้อมกันและ corrupt shared state ได้จริง

Rust ก้าวไปไกลกว่านั้น: รองรับ parallelism จริง (CPU หลายคอร์ทำงานพร้อมกัน) พร้อมกับยังกัน data race ได้ — ไม่ใช่ด้วยการจำกัดให้เหลือ thread เดียว แต่ด้วย type system ตัว marker trait Send และ Sync จะถูกตรวจตั้งแต่ compile time ถ้า type ของคุณไม่ใช่ Send compiler จะไม่ยอมให้ย้ายข้ามไป thread อื่น และถ้าไม่ใช่ Sync ก็แชร์ reference ข้าม thread ไม่ได้

ผลคือคุณได้ประสิทธิภาพของ parallelism จริงพร้อมความปลอดภัยที่ปกติทำได้เฉพาะในโมเดล single-threaded