Thread &
Concurrency Models

3.1 Thread là gì?

Thread là đơn vị thực thi nhỏ hơn process. Một process có thể chứa nhiều thread, các thread chia sẻ memory của process. Vì thế thread thường được gọi là "lightweight process".

Khi process chỉ có 1 thread, đó gọi là single-threaded process. Khi có nhiều thread, multi-threaded process. Trên Linux, thread thực ra là một loại "process" đặc biệt cùng chia sẻ address space — gọi là LWP (Lightweight Process).

3.2 Thread chia sẻ gì, không chia sẻ gì?

3.3 Thread vs Process — bảng phỏng vấn

Khi nào nên dùng cái gì?

• Multi-process: khi cần cô lập (vd Chrome tab — crash 1 tab không sập browser); khi tính song song không cần chia sẻ data; khi muốn restart từng phần.
• Multi-thread: khi cần chia sẻ data nhiều (vd web server xử lý nhiều request cùng struct lớn); khi tạo/destroy thường xuyên.

Ngày nay, cluster + thread pool (Node.js cluster + worker_threads) hoặc process pool (Python multiprocessing) là pattern phổ biến: cluster cho cô lập, thread cho song song trong mỗi cluster.

3.4 User-level vs Kernel-level Thread

Kernel-level Thread

• OS biết về thread, scheduler quản lý từng thread
• Tạo bằng syscall (clone trên Linux)
• Mỗi thread có TID unique trên hệ thống
• Block 1 thread không block thread khác
• Có thể tận dụng nhiều CPU core

User-level Thread

• OS chỉ thấy 1 thread; scheduler ở user space (thư viện) tự manage
• Tạo cực nhanh — không cần syscall
• Block 1 user thread = block toàn bộ process (vì OS thấy 1 thread)
• Không tự động tận dụng multi-core
• Vd: green thread ở Erlang, fibers, coroutines (cũ)

OS hiện đại (Linux, macOS, Windows) dùng kernel-level thread cho thread API tiêu chuẩn (pthread).

3.5 Threading Models — M:1, 1:1, M:N

3 mô hình ánh xạ user thread → kernel thread:

3.5.1 Many-to-One (M:1)

Nhiều user thread map về một kernel thread.

• Tạo thread cực rẻ (toàn user space)
• Nhược: 1 thread block I/O → tất cả block; không multi-core
• Ngày nay ít dùng

3.5.2 One-to-One (1:1)

Mỗi user thread map về một kernel thread.

• Concurrency tốt, multi-core OK
• Nhược: tạo thread đắt (mỗi thread cần kernel resource)
• Linux pthreads, Windows threads, Java thread đều 1:1
• Đây là model phổ biến nhất hiện nay

3.5.3 Many-to-Many (M:N)

M user thread map về N kernel thread (M ≥ N).

• Linh hoạt: tạo nhiều user thread, OS chỉ schedule N kernel thread
• Phức tạp implement
• Vd: Go goroutines dùng M:N (M goroutine, N OS thread). Đây là lý do Go cho phép tạo hàng triệu goroutine.

3.6 Thread Pool — pattern thực tế nhất

Tạo thread không miễn phí. Nếu mỗi request HTTP tạo 1 thread mới rồi destroy, server đông user sẽ chết. Thread Pool giải quyết: tạo sẵn N thread, request đến → đẩy vào queue, thread nhàn rỗi nhặt việc.

Lợi ích

• Tái sử dụng thread → không tốn create/destroy
• Giới hạn concurrency → không quá tải máy
• Predictable resource usage

Ai dùng thread pool?

• Java: ExecutorService, ThreadPoolExecutor
• Tomcat: mỗi HTTP request → thread pool
• Database connection pool: cùng concept với thread pool
• Node.js libuv: default 4 thread cho file I/O blocking
• nginx: dùng worker process pool, mỗi worker là event-loop

Quy tắc kinh nghiệm: kích thước pool = số CPU core × (1 + waitTime/computeTime). Web server I/O-heavy: 2-4× cores. CPU-heavy: 1× cores.

3.7 Node.js Event Loop — single-threaded mà vẫn nhanh

Câu hỏi phỏng vấn JavaScript backend cực kinh điển: "Node.js single-threaded, làm sao xử lý hàng nghìn request đồng thời?"

Câu trả lời nằm ở Event Loop + libuv.

Cách Node xử lý 1000 request đồng thời

const http = require('http');

http.createServer((req, res) => {
  // Mỗi request KHÔNG tạo thread mới
  // Code chạy trên main thread JS
  fs.readFile('/big.json', (err, data) => {
    res.end(data);
  });
}).listen(3000);

Khi 1000 request đến cùng lúc:

1. Main thread nhận từng request, gọi fs.readFile
2. libuv đẩy 4 lệnh đọc file vào thread pool (default 4 workers); 996 còn lại vào queue
3. Main thread không đợi — quay lại nhận request khác
4. Khi worker đọc xong file, libuv push callback vào event loop queue
5. Main thread chạy callback, gửi response, tiếp tục

6 phase của Event Loop

   ┌───────────────────────┐
┌─▶│        timers         │  ← setTimeout, setInterval
│  └──────────┬────────────┘
│  ┌──────────▼────────────┐
│  │   pending callbacks   │  ← syscall errors
│  └──────────┬────────────┘
│  ┌──────────▼────────────┐
│  │     idle, prepare     │
│  └──────────┬────────────┘
│  ┌──────────▼────────────┐
│  │         poll          │  ← I/O callbacks (đa số việc ở đây)
│  └──────────┬────────────┘
│  ┌──────────▼────────────┐
│  │        check          │  ← setImmediate
│  └──────────┬────────────┘
│  ┌──────────▼────────────┐
└──│     close callbacks   │  ← socket.on('close')
   └───────────────────────┘

process.nextTick & Promise microtasks chạy giữa mỗi phase, ưu tiên cao nhất.

3.8 Worker Threads — Node có thread thật

Từ Node 10.5+, có module worker_threads: tạo thread thật (pthread) để chạy CPU-bound work song song với main thread.

// main.js
const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', (result) => {
    console.log('Result:', result);
  });
  worker.postMessage({ n: 40 });
} else {
  // Code chạy trong worker thread
  parentPort.on('message', ({ n }) => {
    // CPU-bound work — fib(40) khá chậm
    function fib(x) { return x < 2 ? x : fib(x-1) + fib(x-2); }
    parentPort.postMessage(fib(n));
  });
}

Worker Threads vs Cluster vs child_process

3.9 Concurrency vs Parallelism — phải phân biệt

Quote nổi tiếng của Rob Pike: "Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once."

Vẽ ra cho rõ

Một system có thể vừa concurrent vừa parallel: vd Node.js cluster — concurrency trong từng process (event loop), parallelism giữa các process trên các core.

Bài tập

Tổng kết chương 3

• ✅ Thread = lightweight process; chia sẻ heap/code/data/fd, riêng stack/registers/TLS
• ✅ Process & Thread đánh đổi: cô lập vs hiệu năng; an toàn vs đồng bộ phức tạp
• ✅ Threading models: 1:1 (Linux pthreads), M:1 (cũ), M:N (Go goroutines)
• ✅ Thread Pool = pattern tái sử dụng thread, giới hạn concurrency
• ✅ Node.js Event Loop: single-threaded JS + libuv thread pool cho I/O — xử lý concurrent dù 1 thread
• ✅ Worker Threads: thread thật trong Node cho CPU-bound work
• ✅ Concurrency (đan xen) ≠ Parallelism (song song thật)
• ✅ Crash 1 thread = crash cả process (chia sẻ address space)