Lần đầu viết service Rust có cache trong bộ nhớ, mình bọc HashMap vào Rc<RefCell<..>> — kiểu "một chủ nhiều người mượn" quen tay. Chạy một thread thì ngon. Mở thêm thread xử lý request song song, compiler chặn ngay:

error[E0277]: `Rc<RefCell<HashMap<String, String>>>` cannot be sent between threads safely

Không phải lỗi logic, không phải bug runtime. Compiler biết trước là mình sắp làm chuyện nguy hiểm, nên nó không cho build. Chuyện hôm nay: Send, Sync thật ra là gì, và khi cần chia sẻ dữ liệu giữa các thread thì nên chọn cách nào.

Send và Sync — compiler tự suy ra, không phải bạn khai

Send và Sync là hai auto trait. Bạn không viết impl Send for MyStruct bao giờ, trừ khi làm unsafe. Compiler nhìn vào các field bên trong rồi tự kết luận:

  • Send: kiểu có thể chuyển quyền sở hữu sang thread khác. Gần như mọi thứ đều Send.
  • Sync: kiểu có thể chia sẻ tham chiếu &T cho nhiều thread cùng lúc. &T chỉ Send khi T là Sync.
Bức tường kính chia đôi căn phòng, một đĩa sáng được chuyền qua ô cửa nhỏ Ảnh: Bức tường kính chia đôi căn phòng, dữ liệu chỉ đi qua được ô cửa nhỏ — đó chính là ranh giới mà Send và Sync vạch ra giữa các thread. — ảnh minh hoạ do AI tạo (Grok Imagine)

Hai trait này lan truyền theo cấu trúc: struct của bạn Send khi mọi field Send. Nhét một Rc vào là cả struct mất Send — và thông báo lỗi chỉ đúng field gây chuyện, khỏi phải tự đi soi từng chỗ truy cập chung.

Rc và Arc khác nhau ở đúng một chỗ

Rc<T> đếm số người mượn bằng Cell<usize> — một biến đếm thường, không nguyên tử. Hai thread cùng clone() một Rc thì bộ đếm có thể mất một nhịp: một thread đọc ra 2, thread kia cũng đọc ra 2, cả hai ghi lại 3 trong khi đúng ra phải là 4. Bộ đếm về 0 sớm hơn thực tế, bộ nhớ bị giải phóng khi vẫn còn người dùng, và bạn có một lỗi memory safety không thể tái hiện ổn định.

Arc<T> thay Cell<usize> bằng AtomicUsize. Cùng API, cùng cách dùng, chỉ khác là phép tăng giảm là nguyên tử. Compiler vì thế cho Arc đi qua thread, còn Rc thì không:

error[E0277]: `Rc<String>` cannot be sent between threads safely
   = help: the trait `Send` is not implemented for `Rc<String>`
   = note: required because it appears within the type `...`

Quy tắc mình tự nhớ: một thread thì Rc, nhiều thread thì Arc. Đừng chọn Arc cho oai — mỗi lần clone là một phép atomic, rẻ nhưng không miễn phí.

Khoá chung: Arc<Mutex<T>>

Khi nhiều thread cùng đọc-ghi một chỗ, cách quen thuộc là bọc Mutex rồi chia sẻ bằng Arc:

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

fn main() {
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = Vec::new();

    for _ in 0..8 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            for _ in 0..10_000 {
                let mut n = c.lock().unwrap();
                *n += 1;
            } // guard rơi khỏi scope ở đây -> nhả khoá
        }));
    }

    for h in handles { h.join().unwrap(); }
    println!("{}", *counter.lock().unwrap()); // 80000
}
Một ngăn kéo khoá ở giữa phòng tròn, nhiều bàn tay xếp hàng chờ một chìa khoá Ảnh: Ngăn kéo khoá giữa phòng, ai cũng phải xếp hàng chờ đúng một chìa — ẩn dụ cho Mutex, nơi quyền truy cập dữ liệu được cấp lần lượt cho từng thread. — ảnh minh hoạ do AI tạo (Grok Imagine)

Ba điều mình học được từ đoạn code trên:

  • lock() trả về Result vì thread giữ khoá có thể panic → khoá bị poisoned. Trong service thật, đừng unwrap() mù quáng; hoặc khôi phục bằng unwrap_or_else(|e| e.into_inner()) nếu dữ liệu vẫn dùng được.
  • Guard rơi khỏi scope là nhả khoá. Đừng giữ nó lâu hơn cần.
  • Nếu chỉ đếm số, dùng AtomicU64 — không cần khoá nào cả, fetch_add là một lệnh.

Đường ống: mpsc channel

Cách thứ hai là không chia sẻ gì cả. Mỗi thread giữ dữ liệu riêng, trao đổi bằng tin nhắn:

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

fn main() {
    let (tx, rx) = mpsc::channel::<Job>();

    let worker = thread::spawn(move || {
        while let Ok(job) = rx.recv() {
            job.run(); // dữ liệu thuộc về thread này, không ai tranh
        }
    });

    for job in load_jobs() {
        tx.send(job).unwrap();
    }
    drop(tx);            // đóng kênh -> worker thoát vòng lặp
    worker.join().unwrap();
}
Những ống kính hẹp chuyền gói sáng giữa các phòng riêng biệt Ảnh: Những ống kính chuyền gói sáng giữa các phòng riêng, không phòng nào dùng chung đồ đạc — mô hình message passing thay cho khoá chung. — ảnh minh hoạ do AI tạo (Grok Imagine)

Channel có một lợi thế Mutex không có: backpressure. mpsc::sync_channel(n) hoặc tokio::sync::mpsc::channel(n) chặn người gửi khi hàng đợi đầy, nên thread chậm không bị nhấn chìm bởi thread nhanh. Với Mutex, thread nhanh cứ khoá-ghi liên tục, còn thread chậm đứng chờ vô vọng.

Lưu ý: mpsc chỉ có một consumer. Cần nhiều worker cùng hút một hàng đợi thì dùng crossbeam-channel hoặc Arc<Mutex<Receiver>> — nhưng lúc đó lại quay về với khoá.

Cái bẫy thật sự: giữ lock qua .await

Đây là lỗi mình gặp nhiều nhất khi review code async Rust:

use std::sync::Mutex;
use tokio::time::{sleep, Duration};

async fn bump(m: &Mutex<u64>) {
    let mut guard = m.lock().unwrap();
    sleep(Duration::from_millis(10)).await;  // ❌
    *guard += 1;
}

Compiler báo future cannot be sent between threads safely. Nghe khó hiểu nhưng lý do rất đời: tokio::spawn cần future Send, mà MutexGuard của std không Send. Lý do sâu xa là khoá gắn với thread đang giữ nó — nếu future bị chuyển sang thread khác giữa hai lần poll thì khoá bị nhả sai chỗ.

Có hai cách sửa. Cách đúng gần như luôn luôn: thu hẹp phạm vi khoá, đừng giữ qua điểm .await.

async fn bump(m: &Mutex<u64>) {
    {
        let mut guard = m.lock().unwrap();
        *guard += 1;
    } // nhả khoá trước khi await
    sleep(Duration::from_millis(10)).await;
}

Cách còn lại là đổi sang tokio::sync::Mutex, loại cho phép giữ guard qua .await. Nhưng nó đắt hơn và dễ tạo ra thứ tệ hơn: một task giữ khoá suốt 200ms chờ mạng, cả trăm task khác xếp hàng phía sau. Nếu bạn thấy mình cần tokio::sync::Mutex ở nhiều chỗ, khả năng cao kiến trúc đang sai — nên chuyển sang channel.

Mình chọn thế nào trong service thật

Sau vài lần sửa lỗi production, mình chốt mấy quy tắc ngắn:

  • Đọc nhiều, ghi ít, cần đọc ngay (config, feature flag, cache nóng) → Arc<RwLock<T>>.
  • Chỉ đếm, chỉ cộng (metrics, request counter) → Arc<AtomicU64>, không khoá.
  • Chuyển việc sang chỗ khác (job, event, log) → channel. Luôn dùng bản bounded để có backpressure.
  • Dữ liệu thuộc về một nơi duy nhất, nhiều nơi cần đọc → cho mỗi thread một bản copy qua channel, đừng chia sẻ con trỏ.
  • Cần khoá để bảo vệ thứ đang chờ I/O → gần như chắc chắn là thiết kế sai.

Điều mình thích ở Rust không phải là nó "khó", mà là những lỗi kiểu này không bao giờ tới được production. Mỗi lần compiler chặn, nó đang trả lại cho mình một buổi tối không phải trực chiến.

📋 Phụ lục thuật ngữ

Thuật ngữ Giải thích ngắn
Send Auto trait: kiểu có thể chuyển quyền sở hữu sang thread khác
Sync Auto trait: &T có thể chia sẻ cho nhiều thread cùng lúc
Rc<T> Đếm tham chiếu không nguyên tử — chỉ dùng trong một thread
Arc<T> Đếm tham chiếu bằng AtomicUsize — dùng được giữa các thread
RefCell<T> Kiểm tra mượn lúc chạy, không phải Sync
Mutex<T> Khoá độc quyền, mỗi lúc một thread được truy cập
RwLock<T> Nhiều reader hoặc một writer
Guard Vật giữ quyền truy cập; rơi khỏi scope là nhả khoá
Poisoned Khoá bị đánh dấu hỏng khi thread giữ nó panic
mpsc Kênh nhiều producer, một consumer
Backpressure Cơ chế chặn người gửi khi hàng đợi đầy

Bạn đang chia sẻ state giữa các task trong service Rust của mình bằng cách nào — khoá chung hay channel? Nếu từng dính lỗi "future cannot be sent" mà sửa bằng cách thêm tokio::sync::Mutex cho nhanh, thử đọc lại chỗ đó một lần nữa xem.

Xem các bài viết khác