Có một đoạn code Rust mình hay thấy trong các service dùng tokio: bọc cả cái state vào Arc<Mutex<...>>, rồi clone tới mọi task. Chạy được, compiler vui, và cho tới lúc lượng request tăng thì không ai nhớ tới nó. Bài này mình so sánh hai cách chia sẻ state giữa các task: khóa chung hay gửi tin nhắn qua channel.
Arc<Mutex>: đơn giản, nhưng nhiều tay cùng thò vào một hộp
Ảnh: nhiều bàn tay cùng thò vào một chiếc hộp có khóa, giống nhiều task cùng giành một `Mutex` — ảnh minh hoạ do AI tạo (Grok Imagine)
Cách quen thuộc nhất là một bộ đếm dùng chung:
use std::sync::{Arc, Mutex};
#[tokio::main]
async fn main() {
let counter = Arc::new(Mutex::new(0u64));
let mut handles = vec![];
for _ in 0..8 {
let c = Arc::clone(&counter);
handles.push(tokio::spawn(async move {
for _ in 0..1000 {
*c.lock().unwrap() += 1;
}
}));
}
for h in handles { h.await.unwrap(); }
println!("{}", *counter.lock().unwrap()); // 8000
}
Ưu điểm là ngắn gọn, đọc một phát hiểu liền. Cái giá là mọi task phải xếp hàng qua một khóa, và có hai cái bẫy mình từng dính.
Bẫy thứ nhất: giữ MutexGuard của std::sync::Mutex qua một .await. Compiler thường chặn vì guard không Send, nhưng nếu chuyển sang tokio::sync::Mutex để "cho qua" thì bạn đổi lỗi biên dịch thành lỗi thắt cổ chai lúc chạy. Quy tắc mình dùng: khóa thật ngắn, lấy dữ liệu ra rồi nhả khóa trước khi await. Chuyện chặn luồng trong async mình có kể ở bài Tokio chậm bất thường — một dòng blocking giấu trong async.
Bẫy thứ hai: lock().unwrap() panic nếu có task khác từng panic khi đang giữ khóa (poisoning). Một task lỗi kéo theo cả đám.
Channel: một chủ sở hữu, mọi người gửi thư
Ảnh: băng chuyền đưa các gói hàng từ nhiều người gửi về một người nhận duy nhất, giống `mpsc` gom lệnh về một task giữ state — ảnh minh hoạ do AI tạo (Grok Imagine)
Hướng còn lại: chỉ một task sở hữu state, các task khác gửi lệnh qua mpsc. Muốn lấy kết quả thì kèm theo một oneshot để trả lời.
use tokio::sync::{mpsc, oneshot};
enum Cmd {
Incr,
Get(oneshot::Sender<u64>),
}
#[tokio::main]
async fn main() {
let (tx, mut rx) = mpsc::channel::<Cmd>(64);
tokio::spawn(async move {
let mut n = 0u64; // state nằm riêng trong task này
while let Some(cmd) = rx.recv().await {
match cmd {
Cmd::Incr => n += 1,
Cmd::Get(reply) => { let _ = reply.send(n); }
}
}
});
tx.send(Cmd::Incr).await.unwrap();
let (rtx, rrx) = oneshot::channel();
tx.send(Cmd::Get(rtx)).await.unwrap();
println!("{}", rrx.await.unwrap());
}
Không còn khóa, không poisoning, và có sẵn backpressure: hàng đợi đầy thì người gửi tự chậm lại. Đổi lại, code dài hơn, mỗi thao tác đọc tốn một vòng gửi nhận, và chuyện thứ tự xử lý do hàng đợi quyết định. Cách này khớp với phần ownership mình đã nói ở Send và Sync — vì sao Rc không qua được thread: dữ liệu chỉ có một chủ thì khỏi cần chia sẻ. Nếu bạn từng viết queue producer/consumer bên C#, Channels trong .NET có cùng ý tưởng.
Chọn cái nào?
Ảnh: cán cân giữa ổ khóa và chiếc máy bay giấy, thể hiện việc đánh đổi giữa Mutex và channel tuỳ bài toán — ảnh minh hoạ do AI tạo (Grok Imagine)
Mình chọn theo mấy câu hỏi nhanh:
- State nhỏ, thao tác đọc ghi ngắn, không await trong lúc giữ:
Arc<Mutex>(hoặcRwLocknếu đọc nhiều). - State phức tạp, có I/O hoặc logic dài khi xử lý: một task sở hữu + channel.
- Cần giới hạn tải, muốn backpressure: channel có bound.
- Chỉ là bộ đếm hoặc cờ:
AtomicU64, khỏi cần khóa.
Kinh nghiệm cá nhân: bắt đầu bằng Mutex cho nhanh, đo đạc, thấy khóa nóng hoặc logic bắt đầu rối thì chuyển sang mô hình actor bằng channel. Đừng tối ưu sớm, nhưng cũng đừng để Arc<Mutex<AppState>> phình thành một cục thần thánh.
Còn bạn thì sao, dự án Rust gần nhất của bạn đang dùng cách nào?
📋 Phụ lục thuật ngữ
| Thuật ngữ | Giải thích ngắn |
|---|---|
| Arc | Con trỏ đếm tham chiếu an toàn giữa nhiều thread |
| Mutex | Khóa loại trừ: một lúc chỉ một bên được truy cập dữ liệu |
| Poisoning | Mutex bị đánh dấu hỏng khi một thread panic lúc đang giữ khóa |
| mpsc | Channel nhiều bên gửi, một bên nhận |
| oneshot | Channel chỉ gửi đúng một giá trị, dùng để trả lời |
| Backpressure | Cơ chế làm bên gửi chậm lại khi bên nhận xử lý không kịp |
| Actor | Mô hình: một task sở hữu state và nhận lệnh qua hộp thư |
